A system design course
Learn system design from one server up.
Grow one app, Chirp, from a laptop to fifty million users. Every lesson starts with something that broke, and works out why, with real numbers and diagrams you can play with.
- Course
System design, from one server up
37 lessons in 8 parts. Grow Chirp from a laptop to 50M users, with a simulation where early choices come back.
Start lesson 1.1 → - Interview practice New
Mock interviews with a whiteboard
URL shortener, rate limiter and more. Clarify, scope, estimate and draw, then compare each stage with a reference answer.
Open the questions → - Engineering blogs New
How real systems broke, and what they learned
Famous outages retold in plain words, with timelines, diagrams and the lessons behind them.
Read the posts → - Low-level design New
Classes, patterns and concurrency
SOLID and design patterns first, then parking lots, LRU caches and elevators, with class diagrams and code.
Start with the concepts →
One path, in order
Each lesson builds only on the ones before it. Nothing assumes a topic you haven't reached yet.
Decisions with consequences
Each part ends in the simulation. Choices you make early come back when Chirp grows.
All the way down
Real numbers, the edge cases, how it fails, and what interviewers ask next.
All lessons
-
1K users
Part 1One server, one database
Ends with Stage 0: MVP
-
100K users
Part 2More users than one server can handle
Ends with Stage 1: Growth
-
2M users
Part 3Choosing how to store data
Ends with Stage 2: New features
-
20M users
Part 4Doing work in the background
Ends with Stage 3: The celebrity
-
50M users
Part 5Splitting data across machines
Ends with Stage 4: Global
-
50M users, every day
Part 6Keeping it running
Ends with Epilogue: Incident day
-
New apps
Part 7New problems
Ends with Chat, ride-sharing, payments, video
-
After the course
Part 8Interview playbook
Ends with Practice
About System Design Road
A free place to learn system design properly, from one server up, and to practise the interviews that test it.
Why this exists
Most system design material falls into one of two traps. It either lists components (load balancer, cache, queue) without saying why any of them is there, or it shows a finished architecture for a famous company and leaves you to guess how anyone got there.
Real systems don't arrive finished. They start small and break in specific ways as they grow, and each piece exists because something went wrong without it. System Design Road teaches it in that order. You follow one made-up app, Chirp, from two founders and one rented server to fifty million users, and every lesson starts with the thing that broke.
What's here
- The course: 37 lessons in eight parts, from what happens when you open an app to consensus, multi-region and payments. Every lesson has real numbers and diagrams you can interact with.
- The simulation: run Chirp yourself. Make the design decisions at each stage, then watch real traffic test them. Early choices come back later.
- Interview practice: ten classic system design questions, practised stage by stage the way a real 45-minute round runs, each with a full walkthrough.
- Low-level design: object-oriented design, SOLID, the classic design patterns and concurrency, then ten LLD interview problems. The parking lot, LRU cache, Splitwise, chess and more, with Java code that compiles and outputs that come from real runs.
- Engineering blogs: well-known outages retold in plain words, with what the engineers learned and the lessons behind them.
How it's made
Three rules run through everything here:
- Explain why, not just what. Every component, pattern and class appears because a requirement or a failure needs it.
- Use real numbers. Estimates are worked through, latencies are realistic, and every code output on the site comes from actually running the code.
- Plain words. If a technical term is needed, it's explained the first time it appears.
Chirp, its founders and its users are fictional. The technology, the numbers and the outages in the blog are real, and each blog post links to the original report it retells.
It's free
Everything you can read here is free, and your progress, notes and whiteboards are saved in your own browser. Nothing is stored about you on a server. The privacy page has the details.
Found a mistake?
Corrections make the site better for everyone. If a number looks wrong, a diagram is unclear, or an explanation skips a step, please let us know.
Privacy
Short version: there are no accounts, no cookies, and no ads. Your progress stays in your own browser.
What stays on your device
Your progress through lessons, your practice answers, whiteboards, notes and reading settings are saved in your browser's local storage. They never leave your device and we can't see them. Clearing your browser's site data deletes them.
Visitor statistics
We use Cloudflare Web Analytics to count visits: which pages are read, roughly where visitors come from (for example a search engine or a link on another site), the country, the type of device, and how fast pages load. It doesn't use cookies, doesn't build a profile of you, and doesn't track you across other websites. The numbers are only ever seen in aggregate.
Services the site relies on
- Hosting. The site is served by Netlify, which, like any web host, processes your IP address to deliver pages and may keep short-lived server logs for security and reliability.
- Fonts. Typefaces are loaded from Google Fonts, so your browser contacts Google's servers to download them.
- Statistics. Cloudflare, as described above.
Each provider handles that data under its own privacy policy.
What we don't do
- No accounts, no sign-in, no passwords.
- No advertising, no ad trackers, no selling of data.
- No email collection on the site at the moment. If that changes, this page will say what's collected and why before it starts.
Changes
If this policy changes, the updated version will appear on this page with a new date.
Last updated: 12 November 2026.
404
That page isn't here.
The link may be old, or the address mistyped. Here are good places to start.
Low-level design
Design the classes, not just the boxes.
Low-level design rounds ask you to turn a problem into clean, working object-oriented code: the right classes, the right relationships, and patterns where they genuinely help. Start with the ideas, then put them to work on real interview problems.
Code examples are in Java, the most common language for these rounds. The ideas carry over to any object-oriented language.
1Concepts and design patterns
Read these in order. Each one builds on the last.
- Part 19 min
Objects and the ideas behind them
Classes and objects, the four pillars, composition, interfaces versus abstract classes, equality and immutability, each shown with a real bug and its fix. Including the subclass that counted 6 when it should have counted 3, and the set that held the same customer twice.
- Part 28 min
SOLID, with code that breaks each rule and code that follows it
Five principles for code that stays easy to change, each shown as a real mistake first, then the fix, with code that runs. How to spot each violation in an interview, where each one shows up in the problems in this track, and when it's fine to bend the rule.
- Part 39 min
Class diagrams: the six lines that describe any design
How to read and draw UML class diagrams in an interview. The class box, all six relationships with the code each one turns into, a lifetime test that settles composition versus aggregation, multiplicity, sequence diagrams for flows, and a step-by-step method that takes a design from requirements to a finished diagram.
- Part 411 min
Creational patterns: Singleton, Factory Method, Abstract Factory, Builder, Prototype
All five classic patterns for creating objects, each built from a real problem. The Singleton race measured (7 instances of a "single" object), factories that keep "which class?" in one place, families that must match, builders that refuse to build bad objects, and the shallow-copy bug in Prototype.
- Part 511 min
Structural patterns: Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy
All seven classic patterns for fitting objects together, each built from a real problem. An adapter that also fixes units, a bridge that turns 6 classes into 5, a retry wrapper whose position changes the result, a flyweight that cut memory 45 times, and how to tell four look-alike wrappers apart.
- Part 615 min
Behavioral patterns: Strategy, Observer, State, Command and six more
Ten patterns for how objects share work and talk to each other, each from a real problem with code that runs. A listener that silently stopped all the others, illegal order states made impossible, undo and redo, a lazy iterator that fetched 2 pages instead of 50, and Visitor next to its modern replacement.
- Part 710 min
Concurrency for LLD: when two threads touch the same object
The thread-safety toolkit for LLD interviews, with every bug reproduced and measured. Lost updates, a stop flag one thread never saw, a concurrent map that still created duplicates, a deadlock caught in the act, a counter 20 times faster than an atomic, queues that push back, and pools versus threads.
2Interview problems
Practise each one stage by stage, drawing your own class diagram on a whiteboard, then read the walkthrough to see the whole approach worked through.
- Easy45 min
Parking lot
The classic first LLD problem. Floors, spot sizes, gates, pricing and payments, and two races to get right.
Not started · walkthrough - Easy45 min
Tic-tac-toe
The warm-up that still sinks people. Board, turns, a fast win check, undo, bots, and two clicks arriving at once.
Not started · walkthrough - Easy45 min
Snakes and ladders
Almost no rules, so the design carries everything: one class for snakes and ladders, boards that can't be broken, house rules, and millions of simulated games.
Not started · walkthrough - Medium45 min
LRU cache
A fixed-size cache that throws away whatever was used longest ago, in constant time, safely shared by many threads.
Not started · walkthrough - Medium45 min
Vending machine
Coins and notes, change from what's really inside, cancels, jams and a service key, modelled with the State pattern.
Not started · walkthrough - Medium45 min
Splitwise
Shared expenses: four kinds of split, money exact to the paisa, balances that always add to zero, simplifying debts, and phones that retry.
Not started · walkthrough - Medium45 min
Movie ticket booking
BookMyShow at the class level: seats per show, holds that expire, paying without holding a lock, double clicks, late payments and deadlocks.
Not started · walkthrough - Medium45 min
Rate limiter (LLD)
The class-level version: four algorithms behind one interface, per-key state with no global lock, safe eviction of idle keys, and combined limits.
Not started · walkthrough - Hard45 min
Elevator system
Several lifts, many floors: which car answers a call, which stop a car serves next, and buttons pressed from everywhere at once.
Not started · walkthrough - Hard45 min
Chess
Pieces that really do need inheritance, legality that no piece can judge alone, castling, en passant and promotion, undo, draws, and rules proven by perft.
Not started · walkthrough