System Design Simulator
Draw a system architecture, then run traffic through it and see where it breaks. Most diagramming tools stop at boxes and arrows. This one models the design: put a cache in front of a database and the database's load actually drops; under-partition a Kafka topic and throughput caps below its declared rate; kill a node mid-run and watch the failure cascade. Every number on the canvas comes from a simulation pass, not a label you typed.
It is free, needs no account, and runs entirely in your browser — no backend, no database, nothing uploaded. Designs autosave to localStorage and can be exported to or imported from JSON.
How to simulate an architecture
- 1Place components. Drag components from the searchable palette onto the canvas, or load one of the 4 worked example architectures to start from something that already works.
- 2Connect them. Draw connections between components to define the request path. Give an edge a weight to split traffic unevenly, such as a 90/10 read-write split.
- 3Tune each component. Open a node in the inspector to set capacity, replicas, latency, failure rate, cache hit ratio, rate limits, timeouts, retries, auto-scaling and resource ceilings.
- 4Run traffic. Choose a request rate and start the simulation. Each node reports its incoming load, utilization, latency and error rate, and turns amber or red as it saturates.
- 5Break it on purpose. Kill nodes, partition the network, inject latency or packet loss, spike traffic, or release the chaos monkey, and watch the failure propagate downstream.
- 6Read the resilience report. The resilience panel kills each component in turn to rank single points of failure, then scores capacity headroom, redundancy and error rate with specific suggestions.
What it models
Traffic simulation
Traffic is injected at client nodes and pushed downstream in topological order. At each hop the engine applies sampling, retry amplification, rate limiting, timeouts, cache absorption, and weighted or fan-out routing — so a cache in front of a database genuinely reduces that database's load.
Capacity modelling
Per-replica throughput is the minimum of every modelled resource ceiling: CPU, memory (via Little's Law), GPU, disk IOPS and partition count. A node can be memory-bound while its CPU sits idle, exactly as in production.
Auto-scaling with cold starts
Replica count is solved from incoming load to hold a target utilization, clamped to a configured maximum, with a cold-start latency penalty weighted by how many replicas are newly warm.
Chaos engineering
Kill nodes, partition the network, inject per-edge latency or packet loss, spike traffic, enable cascading failures to model missing circuit breakers, or turn a chaos monkey loose on the design.
Resilience scoring
Every non-client component is killed in turn to measure how much traffic its loss costs, ranking single points of failure and reporting capacity headroom, redundancy and error rate with concrete suggestions.
65 components and 4 worked examples
Clients, gateways, load balancers, caches, relational and NoSQL stores, queues, coordinators, observability and security components — plus custom nodes with your own category, icon and settings.
Worked examples
4templates ship with the simulator. Each one exists to demonstrate something a static diagram can't:
URL Shortener — A read-heavy redirect path behind a cache, plus a write path that mints unique short codes.
- A cache hit ratio genuinely relieving the database behind it
- Weighted connections splitting a read path from a write path
- Key generation as its own service, with a coordinator handing out ID ranges
E-commerce Checkout — A synchronous checkout path plus an async fulfilment path that fails independently.
- Every component on the sole request path is a single point of failure — the panel ranks them
- An external SLA, timeout, and retries driving the error rate
- Moving fulfilment onto a queue so it fails independently of checkout
Chat / Notification Fan-out — One message delivered to every downstream consumer via Kafka.
- Fan-out delivery: every subscriber receives the full rate, not a share of it
- Partition count capping throughput independently of CPU
Video Streaming — A CDN absorbing playback traffic, with an auto-scaling transcode pipeline.
- A CDN absorbing the overwhelming majority of requests before they reach the origin
- Auto-scaling with a cold-start latency penalty
- Trace sampling reducing observability load
Known limitations
Stated plainly, because a simulator that hides its assumptions isn't much use:
Forward-flow, not steady-state
One pass per tick. Cycles are broken deterministically and the back-edge's traffic is dropped, so nodes inside a loop show approximate numbers. The UI flags this rather than hiding it.
Criticality measures traffic lost, not business impact
Killing a node also removes its descendants' work, so terminal data stores rank below the services in front of them. Losing your orders database scores lower than losing the gateway.
Side-calls split traffic, they don't duplicate it
A node that calls out and then continues isn't modelled; the call takes a share of the flow instead of adding to it.
Some settings are documentation only
Fields such as disk type, consistency level, replication factor and quorum size render for completeness but don't affect the numbers. Each one says so in its own description.
Frequently asked questions
What is the System Design Simulator?
System Design Simulator is a free, browser-based tool for designing system architectures and then running simulated traffic through them. Unlike a diagramming tool, it models the design: every number on the canvas comes from a simulation pass rather than a label you typed.
How is this different from draw.io or Excalidraw?
Diagramming tools draw boxes and arrows; they do not know what the boxes do. This simulator computes throughput, latency, utilization and error rate for each component under a load you choose, so putting a cache in front of a database visibly drops that database's load, and under-provisioning a service turns it red.
Do I need an account, a server, or a backend?
No. Everything runs client-side in your browser. There is no signup, no backend and no database. Designs autosave to localStorage and can be exported to or imported from JSON.
Is it free?
Yes. It is free to use, with no account and no usage limits.
Can I use it to prepare for a system design interview?
Yes — it is a good way to build intuition for the numbers behind common designs. Load one of the 4 worked examples (URL Shortener, E-commerce Checkout, Chat / Notification Fan-out, Video Streaming), raise the request rate, and watch which component saturates first and why.
How does the simulation engine work?
It is a forward-flow approximation, not a steady-state solver. One pass per tick injects traffic at client nodes and propagates it in topological order, applying sampling, retries, rate limits, timeouts, cache hits and routing at each hop. Cycles are broken deterministically and flagged in the UI, since the back-edge's traffic is genuinely dropped.
What can I break with the chaos tools?
You can kill individual nodes, partition the network, add latency or packet loss to specific connections, spike incoming traffic, enable cascading failures to model the absence of circuit breakers, and run a chaos monkey that fails components at random while the simulation is running.
65 components, 4 worked examples, no signup. Open the simulator.