Free · Interactive · Bilingual
System design you can poke, break and replay.
Stop memorising boxes and arrows. Every lesson is a live, deterministic simulation: inject a failure, turn a knob, step through each message and watch the metrics react.
Live: inject a failure and watch the circuit open.
Three ways in
Microservice Patterns
Proven solutions for communication, data consistency, resilience and messaging between services — each one simulated so you can see why it exists.
47 topicsDesign to Scale
Grow an architecture one bottleneck at a time. Every stage shows what breaks, what fixes it and what the fix costs.
17 topicsReal Problems
Production incidents reproduced in a sandbox: symptoms, root cause, the fix and how to prove it worked.
10 topicsFeatured patterns
View allCircuit Breaker
Stop calling a dependency that is failing, fail fast instead, and probe carefully until it recovers — so one broken service cannot drag down everything that calls it.
PatternsRetry
Transparently repeat a failed call when the failure is likely temporary — with backoff, jitter and a strict limit, so retries heal glitches instead of amplifying outages.
PatternsAPI Gateway
Give clients one entry point that routes requests to the right service and handles authentication, rate limiting and response aggregation in one place.
PatternsScaling lessons
View allVertical vs Horizontal Scaling
Grow a web application from one server to a fleet: what breaks at each step, why scaling up hits a ceiling, why scaling out needs stateless instances, and where the next bottleneck appears.
ScaleCaching Strategies
Put a cache in front of a struggling database: how cache-aside works, what drives the hit ratio, how to keep data fresh, and how to survive the moment the cache goes cold.
ScaleScaling with Message Queues
Move slow work out of the request path: a queue absorbs bursts, competing consumers scale the processing, backpressure keeps the system honest and a dead-letter queue catches poison messages.
ScaleReal-world problems
View allCustomers Charged Twice: Duplicate Kafka Processing
A slow downstream made a Kafka consumer miss its poll deadline. The group rebalanced, the same payment messages were processed again — and nothing crashed. How to reproduce, fix and prevent it.
ProblemsCascading Failures: One Slow Service Takes Down Everything
A pricing service three hops from the user became slow. Within seconds every service above it ran out of threads and the whole site returned errors. Reproduce the cascade and contain it with timeouts, a circuit breaker and a bulkhead.
ProblemsKafka Consumer Lag That Never Recovers
Consumer lag grew all day, and doubling the consumers changed nothing. Learn how partitions cap parallelism, how hot keys create one slow partition, and how to size a consumer group.
ProblemsHow interactive learning works
- 01
See the architecture
Each lesson starts from a diagram of real components — services, brokers, caches, databases — that you can zoom into and inspect.
- 02
Run the scenario
A deterministic discrete-event engine simulates every request. Same seed, same result, so you can replay and compare.
- 03
Break it on purpose
Take a dependency down, slow it, crash a consumer. Metrics come from simulated events, never from made-up numbers.
- 04
Understand the trade-off
Switch to advanced mode for percentiles, tuning parameters, production notes and Java/Spring code.
Built on one engine. Every simulation on this site reuses the same behaviors — client, service, circuit breaker, retry, timeout, cache, load balancer, Kafka topic, queue, saga — wired together declaratively.
Learning paths
Survive failing dependencies
Timeouts, retries and circuit breakers — then see what happens when they are missing.
10 lessons
Reliable event-driven systems
From the dual-write problem to exactly-once effects with outbox and idempotent consumers.
7 lessons
Scale a web application
From one server to load-balanced, cached and queue-backed services.
6 lessons
Keep data consistent across services
Own your data, then keep it correct without distributed locks: outbox, sagas, CQRS and event sourcing.
7 lessons
Scale the data tier
Indexes, replicas, caches, partitions and shards — and the races and stampedes that come with them.
7 lessons
Run everywhere, all the time
Stateless instances, autoscaling and capacity, then CDNs, failover and multiple regions.
6 lessons
Shape and observe a system
Monolith or microservices, where to draw boundaries, and the metrics, logs and traces that show what is happening.
6 lessons