Course

All lessons

Every lesson is a short, self-contained read that ends in a checkpoint.

Module 01

Learn the framework

What the round is, the six moves that carry any design, the arithmetic you do out loud, and the mistakes that end interviews early.

01How a system design interview worksIt is a design review with a stranger, on a clock, scored on four signals.Beginner · 9 min 02The delivery framework: six moves, every timeClarify, estimate, contract, design, deepen, close. Same order for every prompt.Beginner · 11 min 03Back-of-the-envelope estimationFour numbers, rounded hard, said out loud with the decision attached.Beginner · 10 min 04Numbers to know coldThe dozen figures that let you size a system without hesitating.Beginner · 8 min 05Common mistakes that sink roundsTen ways strong candidates fail, the fix for each, and how to recover mid-round.Beginner · 9 min

Module 02

Core concepts

The vocabulary every design round runs on: scaling, latency, reliability, availability, failure, consistency and the principles that tie them together.

01ScalabilityGrowth is the default state. Scalability is whether your design survives it.Beginner · 7 min 02Latency, throughput and bandwidthThree numbers that get confused constantly. Percentiles are the only honest latency.Beginner · 7 min 03Reliability: SLIs, SLOs and error budgetsWrite down what 'working' means, measure it, then decide how much failure you can afford.Intermediate · 8 min 04Availability and the ninesEach nine costs roughly ten times as much as the one before it.Beginner · 6 min 05Single point of failureOne question finds them all: what happens if this dies right now?Intermediate · 6 min 06FailoverA spare that nobody promotes is just a second copy of the problem.Intermediate · 7 min 07Fault tolerance and graceful degradationAssume the parts break. Design what the user still gets.Intermediate · 8 min 08CAP and PACELCPartitions are not optional. The real question is what you give up, and only while they last.Intermediate · 7 min 09Consistent hashingAdding a cache node should not invalidate almost everything.Intermediate · 7 min 10Design principles that survive scrutinyThe defaults that make a design defensible when the interviewer pushes.Intermediate · 8 min

Module 03

Networking and APIs

What happens between a tap and a response: DNS, TCP, TLS, HTTP, balancing, and the three API styles you will be asked to choose between.

01How a request travelsFrom a tap on a phone to a row in a database and back, in about 200 milliseconds.Beginner · 8 min 02TCP, UDP, and the need for pushMost designs need a request and a reply. Some need the server to speak first.Intermediate · 7 min 03HTTP that behaves well, and TLS that is not an afterthoughtCaching headers, timeouts, retries, and encryption: the unglamorous parts that decide whether a system stays up.Intermediate · 8 min 04Load balancing without breaking sessionsFour algorithms, two layers, one question: what happens when a backend dies mid-request?Intermediate · 7 min 05REST, GraphQL, gRPC: pick by shape of changeThe right API style follows from who calls it and how often the contract changes.Intermediate · 8 min 06Protecting the API from its own usersRate limits, quotas, backpressure, and graceful degradation — the difference between a spike and an outage.Intermediate · 7 min

Module 04

Data and storage

Choosing and defending a datastore: relational versus document versus wide-column, indexes, isolation levels, replication, sharding, and when a search engine belongs in the design.

01Choosing a datastore without naming brands firstAsk about access patterns, then about consistency, then pick a family — the product name is the last decision.Intermediate · 9 min 02Schemas and the index that saves the queryA query without an index is a full scan, and a full scan is a latency cliff.Intermediate · 8 min 03Transactions, isolation, and the anomalies in betweenACID is a promise with a dial. Know which dial position your workload needs.Advanced · 9 min 04Replication: copies, lag, and the read you cannot trustThe replica is not a backup, and the seconds it lags are where stale data bites.Advanced · 9 min 05Sharding, resharding, and quorumsPartitioning buys scale and takes away joins, uniqueness, and easy rebalancing.Advanced · 9 min 06Search engines and analytics storesTwo systems that are never the source of truth, and how to keep them from drifting.Advanced · 7 min

Module 05

Caching

Where a cache earns its keep, the three strategies worth knowing, how invalidation actually works, and what a CDN changes about a design.

01Where a cache actually helpsA cache is a bet that the same data will be asked for twice, soon, and can be slightly stale.Intermediate · 7 min 02Five cache strategies and the bugs each one hasCache-aside is the default; write-through, write-behind, read-through and refresh-ahead exist for specific shapes.Intermediate · 8 min 03Invalidation: TTL, versions, and the delete that arrives lateThe hard part of caching is not storing the answer. It is knowing when the answer changed.Advanced · 7 min 04The CDN is the biggest cache you ownMost bytes a service sends are static, identical for every user, and never change.Intermediate · 7 min

Module 06

Messaging and streams

Queues versus logs, delivery guarantees, ordering, backpressure, and the event-driven patterns that decouple services without hiding failures.

01Queues and logs are not the same toolA queue deletes a message when it is done; a log keeps it and lets readers move a bookmark.Intermediate · 8 min 02Delivery guarantees, honestly statedAt-most-once, at-least-once, and exactly-once — only two of these exist on a network you don't control.Intermediate · 7 min 03Lag, backpressure and the queue that grows foreverAn asynchronous system does not remove load, it stores it. The queue depth is the bill.Intermediate · 7 min 04Event patterns that survive contact with productionEvents are a decoupling tool and a debugging tax. Use three patterns, not thirteen.Advanced · 8 min

Module 07

Distributed coordination

How independent machines agree on one truth: consensus and quorums, leases and locks, and the uncomfortable reality of clocks and ordering.

01Consensus, quorums and the cost of agreementGetting five machines to agree is not five times harder than one. It is a different kind of problem.Advanced · 8 min 02Leases and locks, and why a lock is a promise about timeA lock without an expiry is a permanent outage waiting for a single crash.Advanced · 7 min 03Clocks lie, so order events by sequenceTwo machines with the same wall clock will disagree by more than you think.Advanced · 7 min

Module 08

Running in production

What keeps a design alive after launch: resilience patterns, observability that answers questions, scaling a fleet without manual surgery, and shipping changes safely.

01Timeouts, retries, circuit breakers and bulkheadsMost outages are a slow dependency plus unlimited patience.Intermediate · 8 min 02Observability that answers a question at 3amDashboards are not observability. Being able to answer "why is checkout slow right now?" is.Intermediate · 7 min 03Scaling a fleet without manual surgeryThe interesting part is not adding servers. It is what breaks when the number of servers changes.Intermediate · 7 min 04Shipping without breaking the designSchema migrations are the part of deployment that cannot be rolled back by redeploying.Intermediate · 7 min

Module 09

Performance anti-patterns

The "why is it slow?" playbook: measuring before guessing, reading tails instead of averages, and the recurring mistakes that turn small inefficiencies into capacity bills.

01Why is it slow? A method, not a hunchMeasure the layer, then the hop, then the line of code. Guessing wastes the incident.Advanced · 8 min 02Seven anti-patterns that quietly cost a fortuneNone of these are bugs. All of them multiply traffic, latency or storage until the bill arrives.Advanced · 8 min

Module 10

Security

Who is calling, what may they touch, and what happens if the data leaks: identity and authorisation, protecting data in transit and at rest, and defending the public edge.

01Authentication, authorisation and the token that carries bothLogin is a solved problem. Deciding what a logged-in user may touch is the design work.Intermediate · 8 min 02Protecting data in transit, at rest and in backupsEncryption is not a checkbox; it is a decision about who holds the key.Intermediate · 7 min 03Rate limits, quotas and the public edgeEvery public endpoint will be called by something you did not design for.Intermediate · 7 min

Module 11

Key technologies and patterns

The map of real systems: which category each tool belongs to, what it is good at, and the handful of patterns that keep reappearing across every design.

01The technology map: categories before namesInterviewers remember the reason you chose a category, not the vendor you named.Beginner · 8 min 02Twelve patterns that reappear in every designMost design problems are one of a dozen shapes wearing a product name.Advanced · 8 min

Module 12

Practice problems

Twelve designs worked end to end with the six-move framework: requirements, estimates, API, data model, high-level design, deep dives and bottlenecks.

01Design a URL shortenerThe warm-up problem. Small surface area, one interesting property: reads outnumber writes by a hundred to one.Beginner · 8 min 02Design a distributed rate limiterA counter that must be shared, atomic, and fast — and must still work when the counter store is down.Intermediate · 8 min 03Design typeahead / autocompleteTen keystrokes, ten queries, and a 100 ms budget. Precompute almost everything.Intermediate · 7 min 04Design a web crawlerA polite, deduplicating pipeline that has to decide what to fetch, how often, and when to stop.Intermediate · 8 min 05Design a news feedThe classic fan-out trade-off, plus the part people forget: ranking and caching the result.Intermediate · 8 min 06Design a chat applicationDurable connections, ordered messages per conversation, and delivery that survives a phone going offline.Advanced · 8 min 07Design a notification serviceMulti-channel delivery where the hard parts are preferences, deduplication and not waking someone twice.Intermediate · 7 min 08Design a ride-hailing matcherFind nearby drivers, pick one, and never assign the same driver twice.Advanced · 8 min 09Design a video platformUpload is a pipeline; playback is a caching problem. Treat them as two systems.Advanced · 8 min 10Design a file sync serviceMetadata consistency is the hard part; the bytes are just blobs in a bucket.Advanced · 8 min 11Design product searchAn inverted index, a relevance function, and filters that must stay fast as the catalogue grows.Advanced · 7 min 12Design a payments ledgerThe problem where correctness beats availability, and every rule is about failure.Advanced · 8 min