Breakscale: a system design simulator that you load until it breaks

What Breakscale teaches

Distributed systems concepts, queues, backpressure, cascading failure, are hard to grasp from prose because you never see them fail in slow motion. Breakscale makes that visible. It is a browser-based system design simulator where you build a system on a canvas, load it until it breaks, and watch why it breaks, with the behavior grounded in queueing theory. The audience is engineers learning system design, students, interview preparers and anyone who wants intuition for how systems behave under load, rather than someone doing production capacity planning. It runs as a web app with a hosted version, and its premise is experiential learning: instead of reading that a queue saturates or a slow dependency causes a cascade, you assemble components, turn up the load, and observe latency climb and the system tip over, which builds intuition that a diagram cannot.

A canvas simulation grounded in queueing theory

The mechanism is an interactive canvas backed by a queueing-theory simulation. You place and connect components, services, queues, dependencies, on a canvas to model a system, then apply load and the simulator computes how requests flow, queue, wait and fail, so you see latency and throughput respond and can find the point where the design breaks. Grounding it in queueing theory is what makes the behavior principled rather than arbitrary: the way latency rises as utilization approaches capacity, and how a bottleneck propagates, follow the math the field actually uses, so the lessons transfer to real reasoning. The value is the why, the simulator does not just report a failure, it lets you watch the mechanism, a saturating queue, a slow node, back up through the system, which is exactly the causal understanding system design interviews and real design reviews demand.

Running Breakscale

Breakscale has a hosted version you can open directly, and it runs locally as a front-end app using the Bun toolchain. To run it yourself you clone the repository and start it:

git clone https://github.com/xevrion/breakscale.git
cd breakscale
bun install
bun dev

That starts the development server for the web app, and there is also a worker component in the repository. The quickest start, though, is the hosted site: open it, place a couple of components on the canvas, connect them, and turn up the load to watch latency rise and the system break. The first real use is building a minimal system, one service behind a queue, loading it past capacity, and observing where and why it fails, which demonstrates the core loop, build, load, break, understand, before you model more elaborate designs.

Where a learning simulator is bounded

The limitations are those of a teaching model. Breakscale is a simulation grounded in queueing theory, which makes it principled but still a model: it abstracts away much of real-world complexity, network variance, retries and their storms, garbage collection pauses, real hardware behavior, so it builds intuition rather than predicting a specific production system's numbers. It is explicitly a learning tool, so it is not a capacity planner you would size a real deployment with, and treating its outputs as production forecasts would misuse it. As a browser simulation, elaborate systems and high load are bounded by what runs smoothly in the browser. And the fidelity of any lesson depends on how faithfully your canvas model reflects the real system. These are appropriate boundaries for an educational simulator, and they mean Breakscale is for understanding mechanisms, not for producing numbers you deploy against.

Breakscale versus books or ad-hoc calculation

The alternatives for learning this are distributed-systems books and courses, or working the queueing-theory math yourself with a spreadsheet. Books and courses give depth and rigor but are passive: you read that utilization drives latency without watching it happen. Doing the math by hand is precise but tedious and does not show the dynamics of a whole system under changing load. Breakscale's difference is that it is interactive and visual, you build, load and watch failure unfold, which turns abstract results into observed behavior and builds intuition faster for many learners. It complements rather than replaces the theory. Use books and the math for rigor and depth; use Breakscale to develop the felt sense of how systems saturate and cascade, especially when preparing for system design interviews or building intuition before a real design review, and pair it with the underlying theory for the full picture.

MIT license and maintenance

Breakscale is MIT-licensed, so it is freely reusable, and it is a TypeScript web app built with the Bun toolchain, with a worker component and the usual open-project scaffolding including a code of conduct, security policy and a funding manifest. The last push was on 2026-09-14. Adopt it when you want to build intuition for distributed-systems behavior under load, for study or interview preparation, use the hosted version to start immediately, or run it locally with bun install and bun dev to modify it, and treat it as a tool for understanding failure mechanisms rather than a production capacity planner. Its grounding in queueing theory is what makes the lessons transferable, and pairing the hands-on simulation with the underlying theory gives both the intuition and the rigor.

Editorial conclusion

Use Breakscale if you want to build intuition for how distributed systems behave under load by assembling a design, loading it until it breaks, and watching why, for study or system design interview preparation. Do not treat it as a production capacity planner, since it is a queueing-theory learning model that abstracts away real-world complexity. Try the hosted version to start immediately, or run it locally with bun install and bun dev, and pair it with distributed-systems theory for rigor.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. Project website
4. README
5. xevrion/breakscale on GitHub