A capacity-planning tool that teaches
Design it. Break it. Fix it — before production does.
Draw a system, give it traffic, and get an honest answer: which part fails first, at what load, what it does to latency, and what it costs to fix. Every number shows its working.
- 8
- worked problems
- 12
- concepts, each with a widget
- 18
- part types, plus your own
A real design from the library, with the engine’s verdict on every part. Open it in the playground and turn the traffic up until something goes red.
If you’re learning
Read a design, then watch it fail.
Every problem is a write-up that explains its choices, a diagram that names its own trade-offs, and sliders that let you push traffic until the bottleneck appears. Twelve concepts each come with a widget built to make one idea click — why caches lie, why retries make outages worse, why a majority can never split.
If you’re building
Size your own system before you pay for it.
Draw the design you actually run. Declare what enters where, what each part can handle, how copies scale. The engine tells you what saturates first and at what traffic, runs a spike through it with your autoscaling policy, prices it three ways, and lets you break it on purpose — a cache down, a slow dependency, a lost region — to see who pays.
What makes it different
Not a drawing tool with numbers on it. A model you can argue with.
Declared, not guessed
You state how traffic splits, fans out and routes. The tool never infers what your load balancer does — it asks, then shows the arithmetic per part so you can check it.
Time, not just steady state
Run a spike through the design with a real autoscaling policy — boot time, the metric it watches, its cooldown — and see the window where new copies are not there yet.
Honest about its limits
Latency is a textbook approximation and says so. Failure modes cover what the model can express and name what it cannot. Defaults are flagged until you replace them.
- Workloads with peak ratios
- Concurrency ceilings
- Third parties as fixed limits
- N−1 per part
- Spike timeline with autoscaling
- Cost: as drawn · sized for peak · autoscaled
- Scenarios and side-by-side compare
- Cache-miss storm · slow dependency · lost region · retry storm
- Share by link, no account
Start here
Three problems, three concepts.
URL Shortener
Turn a long URL into a short code and redirect on lookup. The classic warm-up: tiny write path, enormous read path, and a key-generation problem hiding underneath.
7 parts · 2 workloads
Rate Limiter
Decide, in under a millisecond and across a whole fleet, whether this request is allowed through. The algorithm choice and the counter-sharing problem are the two real questions.
6 parts · 1 workloads
Distributed Key-Value Store
Build the storage layer the other problems assume exists. Consistent hashing for placement, quorums for consistency, and an explicit answer to what happens during a partition.
4 parts · 2 workloads
Caching
Every write strategy trades durability against how often you touch the store.
TrafficRetries, Backoff and Jitter
Every retry adds load to the thing that just failed. Backoff and jitter trade a little extra latency for not making the failure worse.
ConsistencyConsensus
A majority quorum survives minority failures and never splits, at the cost of a round trip to most of the cluster on every decision.
The bottleneck is already in your design. Find it on a Tuesday, not at launch.
6 templates to start from, or a blank canvas. No account, nothing uploaded — your designs stay in your browser.