System Design From First Principles

From one order on one server to systems that survive millions of people.

62 open lessons · practice and review with a pass

Part 0: The first order

How one request travels, how to design anything, and the numbers that change decisions.

What happens when one order is placed?: What happens between tapping “Order” and seeing “Confirmed”?
How to design anything: How do you go from a vague idea to a design you can defend?
Numbers that change decisions: Which numbers should change your design, and how do you get them in two minutes?

Scale a single service: more servers, caches, a CDN and a clean API. Then two complete designs.

Load balancing and statelessness: What happens when one server is not enough?
Caching: How do you serve the same answer thousands of times without asking the database each time?
CDNs and blob storage: Where should photos and files live, and how do they reach a phone far away quickly?
API design and auth basics: What should the contract between the app and the server look like?
Design a URL shortener: How do you turn a long tracking link into seven characters, and serve it fast for years?
Design a rate limiter: How do you stop one script from eating everyone’s capacity, without hurting real customers?

Open the box everyone treats as magic: pages and B+trees, the log that survives a crash, isolation, query plans, LSM trees and the NoSQL family.

How a row is stored: Where does a row physically live, and how does an index find it in three steps out of millions?
The write-ahead log and crash recovery: How can a database promise your order is saved when the power fails a millisecond later?
Transactions, isolation and MVCC: What can go wrong when two people change the same data at the same moment, and what does each isolation level actually prevent?
Query plans and indexes in practice: Why is the same query fast one day and slow the next, and which index would fix it?
LSM trees and the NoSQL family: How do stores built for heavy writes work, and what are document, wide-column, key-value, graph, search and time-series stores each good at?
Choosing a data model: Relational, document or wide-column: how do you choose, and when should you copy data instead of joining it?

Copies, slices, agreement: replication, partitioning, consistency and consensus, then a store and a cache built from them.

Replication: How do you keep copies of data on several machines, and what goes wrong when they disagree?
Partitioning and consistent hashing: How do you split data across machines so each holds a fair share?
Consistency, CAP and PACELC: When copies disagree, what exactly can a system promise?
Consensus and leader election: How do several machines agree on one leader, even when some of them fail?
Design a key-value store: How do you build a store that never says no to a write, even when machines die?
Inside a cache: how Redis works: How does one Redis process serve a hundred thousand requests a second, and what happens when its memory is full?
Design a distributed cache: How do you cache across many machines when everyone wants the same key at once?

Asynchronous work and real-time delivery, then four designs that depend on them.

Queues, retries and idempotency: How do you do slow work later without doing it twice?
Real-time delivery: How does the server tell a phone that something changed?
Design a news feed: How do you build “today’s menus” from 2,000 cooks, one of whom is famous?
Design a chat system: How do you deliver messages in order, to people who are online and offline?
Design a notification system: How do you send every notification once, even when providers fail?
Design search autocomplete and Top-K: How do you suggest “paneer” after two letters, in 50 milliseconds?

Logs and Kafka from the inside, then video, file sync and crawling, and seeing inside it all.

Logs, streams and back-pressure: What is the difference between a queue and a log, and what happens when consumers fall behind?
Inside Kafka: How does Kafka keep millions of messages in order, survive a dead broker, and avoid processing one twice?
Design a message queue: How do you design the kitchen’s order pipeline on a log that many teams read at their own pace?
Design video streaming: How does a recipe video play smoothly on a slow phone?
Design file sync: How do two devices keep the same folder without sending everything every time?
Design a web crawler: How do you fetch a billion pages politely?
Observability: How do you know what your system is doing right now?
Design metrics and monitoring: How do you store and query millions of measurements a minute?

Where things are, who gets the last one, and money that must never be wrong across several services.

Design proximity search: How do you find kitchens near me, fast, out of thousands?
Design rider matching: How do you match moving riders to pickups every few seconds?
Design ticketing and booking: How do you sell 500 thalis to 20,000 people fairly?
Distributed transactions: two-phase commit: Can one transaction span two databases, and what happens when the coordinator dies halfway?
The outbox pattern and change data capture: How do you update your database and tell other services about it, without ever doing one and not the other?
Sagas and event sourcing: How do you run a business process across several services when some steps must be undone?
Design a payment system: How do you take money exactly once, and prove it?

Surviving failure, editing together, serving an LLM, and going global.

Resilience: How do you stop one slow dependency from taking everything down?
Design collaborative editing: How do two people edit the same document offline and still agree later?
Design LLM serving with RAG: How do you serve a support bot to thousands of customers at a sane cost?
Going multi-region: What changes when your users and data live in several regions?

Change it without downtime, size it and pay for it, secure it, and write the decision down. Then design on your own.

Changing a running system: How do you change the schema, the code and the data while customers keep ordering?
Capacity planning and cost: How many machines will next year need, and what will they cost?
Security and multi-tenant isolation: How do you keep one cook, partner or customer from seeing or breaking another’s data?
Writing a design doc: How do you write a design down so others can review it, and so you remember why you chose it?
Capstone: design on your own: Can you design a system on your own, and defend it?

Classic designs, each grown from a lesson you already know.

Unique ID generator: How do many machines hand out unique, roughly time-ordered ids without asking each other?
Real-time leaderboard: How do you rank 200,000 people live and show anyone their position instantly?
Ad-click aggregation: How do you count clicks per minute correctly when events arrive late and twice?
S3-like object store: How do you keep petabytes safe without storing everything three times?
Distributed email: How do you store years of mail cheaply and still search it in a second?
Maps and routing: How do you find the fastest route across a city graph of millions of roads in milliseconds?
Digital wallet: How do you build a balance that can always be proved, event by event?
Stock exchange: How does an exchange order millions of bids fairly in microseconds?
Distributed job scheduler: How do you run every scheduled job once, on time, when machines die?
Spanner and TrueTime: How can a database spread over continents still order every transaction?