Skip to content
ScaleLab

System design studio

Draw the system. Run the traffic. Watch what breaks.

ScaleLab turns the diagram on your canvas into a running discrete-event simulation. Queues fill, breakers trip, p99 climbs, and a system that was healthy a moment ago collapses under a retry storm. Then rehearse explaining all of it, with guided interview packs.

Watch a preset run
  • 34 architecture components
  • 32 ready-to-run presets
  • 39 guided interview packs

The studio

Three tools around one canvas

  1. Diagram / the canvas

    Thirty-four real parts, from load balancers and caches to sharded stores, sidecars, and vector databases. Wire them, annotate with the pen, pin requirements cards, and sketch freehand. Clean Canvas mode strips the telemetry away when you just want to draw.

    • notes & sections
    • pen & eraser
    • requirements cards
    • Cmd+K search

  2. Simulate / the engine

    Steady, ramp, spike, and diurnal traffic shapes run through your topology with gamma-distributed service times, concurrency limits, and backpressure. Every number comes from the discrete-event engine, never a formula: p50 through p99, queue depth, goodput, per-node utilization, and a request tracer that follows one call through the whole path.

    • p50 / p90 / p99
    • queue depth
    • goodput
    • request tracing
    • cost estimate

  3. Rehearse / interview practice

    Thirty-nine guided packs walk the classics, from URL shortening to flash sales: requirements, estimations, entities, API design, and deep dives with tradeoffs. Pin every section onto the canvas beside a runnable starter system, then grade yourself with auto-checked labs against the live simulation.

    • 39 packs
    • 34 concept lessons
    • auto-graded labs
    • glossary

The engine

Break it here, not in production

The simulator ships the failure modes that actually take systems down. Each one is a behavior of the engine, not a label on a box, and each one is yours to trigger, watch, and design against.

  • Retry storms

    Unmanaged retries multiply traffic and crush a database that was already recovering.

  • Circuit breakers

    Closed, open, half-open: failing downstreams get isolated before they take callers with them.

  • Backpressure

    Queues fill, latency climbs, and consumers fall behind until shedding kicks in.

  • Rate limiting

    The gateway sheds low-priority traffic before backlogs form downstream.

  • Bulkheads

    Failure domains stay isolated when one pool drowns; the rest of the system keeps serving.

  • Autoscaling

    Instances boot with realistic delays and hysteresis, so scale-out never saves you instantly.

  • Hot keys

    Celebrity bursts skew sharded fan-out and one partition burns while the rest idle.

  • Cascade failure

    One saturated node slows its neighbors, times them out, and walks the outage across the map.

Presets

Start from a system you know

Thirty-two ready-to-run presets: reconstructions of real production architectures, interview classics, and foundational patterns. Open one, run its traffic, then bend it until something snaps.

  • Discord · websocket fan-out
  • Uber · GPS streams
  • Netflix · edge CDN
  • Spotify · audio vs metadata
  • Twitter / X · timeline caches
  • Stripe · idempotency keys
  • WhatsApp · connection holding
  • Ticketmaster · seat holds
  • TinyURL · cache-heavy reads
  • LeetCode · contest bursts
  • CDN + origin
  • Sharded DB
  • Multi-region
  • Event-driven

Your next design deserves a load test

Everything runs in your browser. No account, no backend, nothing leaves your machine.

runs locally · open source · MIT