I could read the system design books and still had no gut feeling for what actually happens under load. I understood retries, queues, and timeouts individually, but couldn't really picture how they interact when things go wrong.
So I built LoadSketch, a free, open-source system design simulator. You put components on a canvas (load balancers, API servers, caches, databases, queues), send traffic, and see what breaks first.
One of my favorite examples is a retry storm. A traffic spike overloads the API servers, and even after traffic drops back to normal, retries keep the system overloaded.
I tried three versions of the same design under the same traffic spike:
- No retry budget: 73% errors. The system doesn't recover.
- 10% retry budget: 38% errors, but the system recovers within seconds after the spike ends.
- More API servers + retry budget: 0% errors, but the estimated monthly cost goes from $839 to $904.
The video shows all three runs and a side-by-side comparison of their results.
None of this is a scripted animation. The requests and simulated metrics come from a discrete-event simulation. Change a timeout, add an instance, or adjust the retries, and the result changes.
A few other things I've added:
- Find limit: gradually increases traffic until the design fails, showing which component becomes the bottleneck.
- Version comparisons: compare designs by error rate, p99 latency, estimated monthly cost, and what changed.
- On-call practice: 8 incidents where the fault is hidden and you diagnose it from the metrics.
- 47 runnable examples: retry storms, cache stampedes, split brain, bad config pushes, and more.
- Terraform import: turn an AWS Terraform plan into a simplified design you can simulate.
It's completely free, MIT-licensed, and runs in your browser. No installation or signup required.
Try it: https://loadsketch.mclee.dev
GitHub: https://github.com/minchenlee/loadsketch
One important limitation: this is a learning tool, not a production capacity planning tool. I've checked the model against queueing theory and other reference cases (25 checks, 24 within tolerance), and documented the known deviations. Real systems are more complicated, and I don't want to pretend the simulator captures everything.
I built it with Claude Code, reviewing and testing the changes.
The part I care about most now is making the simulation behave more like real systems. And I know I can't get there alone.
If you've dealt with retry storms, overload, or similar incidents in production, I'd love to know whether the behavior in the video matches what you've seen. Especially if something looks wrong.
Contributions are welcome too. Some areas where help would be valuable:
- Real incidents and architectures turned into runnable examples
- New components or mechanisms the simulator doesn't support yet
- Validating the model against queueing theory or real measurements
- New practice questions and learning scenarios
- Terraform importer support for more services
You don't need to contribute code. Even describing a case where the simulation behaves differently from a real system would be incredibly useful.
Adding a practice question is a single JSON file, and adding an example is a JSON file plus one line. There's a step-by-step guide in the repo.
Contributing guide: https://github.com/minchenlee/loadsketch/blob/main/CONTRIBUTING.md
Open issues: https://github.com/minchenlee/loadsketch/issues
I'd love to hear what you think, especially from people who've worked on systems under real production load.