From robot fights to a data product
BattleBots is easy to watch as a series of dramatic matchups. It is more interesting to analyze as a collection of data: which robots win, how weapon types compare, what fans are talking about, and how builders shape the competition over time.
That was the idea behind BattleBots Analytics, a full-stack dashboard I built for the Bright Data × BattleBots challenge. The live app is at battlebots-analytics.vercel.app.
Rather than making one chart and calling it an analytics tool, I organized the app around six questions:
- Which robots have the strongest win rates?
- What are fans saying, and how much engagement are posts getting?
- How might two robots fare against each other?
- What parts and sponsors are associated with each robot?
- Which weapons and strategies are appearing across seasons?
- How are builders connected, and where are they based?
Six views, one dataset
The dashboard has separate views for robot win rates, fan sentiment, head-to-head comparisons, sponsors and parts, meta analysis, and a builder community map. The goal is to make each view answer a different question, while keeping the underlying project understandable as one system.
The frontend uses Next.js 14, React, Tailwind, and Recharts. The backend is a FastAPI app with SQLAlchemy and SQLite. The frontend talks to the backend through REST endpoints, including endpoints for robots, leaderboards, sentiment, matchups, sponsors, and community data.
The data pipeline has to work when scraping doesn't
A dashboard that depends on a live scrape every time someone opens it is fragile. To make the project usable without a live data request, I included a cache-first ingest path. The repository documents 149 pre-scraped pages in the cache; at startup, the backend loads cached data and merges live results when available.
Bright Data is used to collect public web data, including BattleBots wiki pages and Reddit discussion. The repository also documents a bundled seed and cache-data path, so the app can run without an API key. That separation makes it possible to work on the interface and API locally without making live scraping a prerequisite.
Matchup predictions, with the method visible
The head-to-head view combines a few interpretable signals rather than hiding the prediction behind a black box. The documented score weights win rate at 45%, knockout rate at 25%, and a weapon-matchup edge at 30%. Head-to-head history can nudge the result, and the app labels confidence as high, medium, or low based on the probability margin.
That makes the result easier to explain, but it should be read as a heuristic, not a guarantee that the model predicts real fights accurately. Its output depends on the quality and coverage of the underlying data, and the matchup formula is a transparent starting point that can be tested and improved.
What I wanted this project to demonstrate
This project brings together data collection, a cache-backed ingestion path, a REST API, and several focused dashboard views. It also makes the boundary between collected data and derived analysis visible: win-rate rankings come from match records, while sentiment and matchup scores are calculated for different purposes.
The repo includes setup and deployment documentation, and the project is released under the MIT License. If you want to explore it, start with the repository README or try the live demo.
For me, the useful challenge was not just building another dashboard. It was taking a niche subject with scattered information and turning it into a set of questions an enthusiast can actually explore.
Top comments (0)