I kept reading about load balancers, caches and sharding, and a week later I'd forgotten all of it.
The problem wasn't the explanations. It was that a diagram never fails. You draw a load balancer, three servers and a database, it looks right, and you never find out what would actually happen when 6,000 people show up at once.
So I built Bugpit, a free browser game where your system design actually runs, and actually breaks.
How it works
You build an app's backend from blocks: users, app servers, load balancers, caches, databases, queues. Then you press Run traffic.
A simulator sends requests through your design and shows you what happens:
- parts that can't keep up turn red
- requests start failing, and failed ones get retried, which makes things worse
- you see how long the slowest 1% of requests wait (the p99)
- you see what the design would cost each month
Then you fix it, run it again, and see if your fix worked. No code needed.
A walkthrough: Level 3, "you hit the news"
Here's the level that made the idea click for me.
The setup: 6,000 requests a second hit your app. One App Server handles about 2,000. You start with one server and one database.
Run it: the App Server turns red. Over 90% of requests fail, and the slowest ones take 6 seconds.
Fix 1, scale out: add a Load Balancer and give the App Server 4 machines. Run it again.
New problem: the servers are fine now, but the database can't keep up. Every fix moves the bottleneck somewhere else, and finding the next one is the real skill of system design.
Fix 2: 90% of requests are reads. Add a Read Replica to answer reads, and give the primary database a bigger machine for the writes.
Run it one more time: all green. 6,000 requests a second, none failing.
That loop of break it, find the bottleneck, fix it and break it again teaches more than any diagram I've drawn.
What's inside
- 70+ levels, from your first user to an app running around the world
- Core concepts: stateless servers, picking a shard key, leader election, transactions, auth, observability
- Real app levels for Netflix, Instagram and more, built on numbers these companies have shared
- Real outages you have to survive
- Budget levels, where the cheapest design that survives wins
- Timed interview rounds, marked against a checklist you only see after you submit
- A daily puzzle
- Short questions at the end of each level, so the idea sticks
The first levels don't need an account. A free account opens 34 levels, the daily puzzle and your first interview round.
How the simulator works (roughly)
Each part has a capacity: how many requests a second one machine can handle. Traffic is split by your load balancers, reads and writes go where your design sends them, and anything over capacity queues up, slows down, and eventually fails. Failed requests can be retried, which adds load, which is how small overloads turn into outages.
Prices come from real cloud price lists, and network delays come from named sources. Speeds that depend on your own code are marked as estimates. It's a teaching model, not a load test, so test your real app before trusting any number.
What I learned building it
- Breaking things teaches faster than building them. People spend more time crashing servers on purpose than building perfect designs, and that's where the learning happens.
- Every fix moves the bottleneck. I knew this in theory. Watching it happen level after level made it stick.
- Cost changes the answer. "Add more servers" is always right until there's a budget.
Try it
👉 bugpit.vercel.app: free, in your browser, no code.
I'm building it on my own, so I'd love feedback in the comments: where did you get stuck, and if you work on real systems, which numbers look wrong to you?

