A written version of the interactive roadmap above — every station, what you'll learn, and a small thing to build — laid out for reading, reference and search.
Fundamentals Start here
F1. Client–Server & APIs
Beginner · 45 min
Every system starts with a client asking a server for something. Requests and responses, statelessness, REST vs RPC, and status codes are the vocabulary of distributed systems — get these right and every later diagram makes sense.
Skills: Request / response · REST vs RPC · Statelessness · Idempotency & status codes
Build it: Design the API for a simple pastebin: list the endpoints, methods, and request/response shapes. Which calls are idempotent?
F2. Back-of-the-Envelope
Beginner · 45 min
Before you draw a single box, estimate the numbers: queries per second, storage per year, bandwidth, and how many servers that implies. Capacity math turns "it should scale" into a defensible design — and it is the first thing interviewers probe.
Skills: QPS estimation · Storage & bandwidth math · Powers of two · Peak vs average load
Build it: Estimate the storage and QPS for a URL shortener serving 100M new links/month with a 100:1 read/write ratio. Show your working.
F3. Databases: SQL vs NoSQL
Beginner · 60 min
The database is the heart of most designs. Relational (SQL) gives you joins, transactions, and strong schemas; NoSQL families — key-value, document, wide-column — trade some of that for scale and flexibility. Knowing when each fits is core.
Skills: Relational vs NoSQL · Transactions & ACID · Indexing basics · Schema design
Build it: For a chat app, decide where messages, user profiles, and presence each live — and justify SQL vs NoSQL for each.
F4. Caching
Intermediate · 45 min
A cache is the single highest-leverage tool for read-heavy systems: keep hot data in memory and spare the database. But caches bring their own problems — invalidation, staleness, eviction, and the thundering herd when they go cold.
Skills: Cache-aside · TTL & eviction (LRU) · Invalidation · Thundering herd
Build it: Design the caching layer for a read-heavy profile service: what do you cache, for how long, and how do you handle a cache miss storm?
F5. Load Balancing
Intermediate · 45 min
One server is a single point of failure and a scaling ceiling. A load balancer spreads traffic across many, routes around unhealthy nodes, and lets you scale horizontally. Layer-4 vs layer-7, health checks, and sticky sessions are the knobs.
Skills: L4 vs L7 · Round-robin / least-conns · Health checks · Sticky sessions
Build it: Sketch how a request reaches one of five app servers. Where does the load balancer sit, and what happens when a server fails a health check?
F6. CAP Theorem
Intermediate · 45 min
When a network partition hits, a distributed system must choose: stay consistent (reject some requests) or stay available (serve possibly-stale data). CAP names that unavoidable tradeoff, and it quietly drives most real design decisions.
Skills: Consistency vs availability · Partition tolerance · CP vs AP systems · Eventual consistency
Build it: For a shopping cart vs a bank ledger, argue whether you would lean CP or AP, and what the user sees during a partition.
Building Blocks Level up
T1. Sharding & Partitioning
Intermediate · 60 min
When data outgrows one machine, you split it — by hash, by range, or by directory. Sharding scales writes and storage horizontally, but introduces hard problems: cross-shard queries, hot shards, and rebalancing as you grow.
Skills: Hash vs range partitioning · Shard keys · Hot spots · Rebalancing
Build it: Choose a shard key for a social app's posts table. What query gets slow because of your choice, and how would you mitigate it?
T2. Replication & Consistency
Advanced · 60 min
Copies of your data buy availability and read scale — but now they can disagree. Leader/follower vs multi-leader, synchronous vs async replication, and the consistency models (strong, eventual, read-your-writes) are the tradeoffs to master.
Skills: Leader / follower · Sync vs async replication · Replication lag · Consistency models
Build it: A user updates their profile, then immediately reloads and sees the old value. Explain the replication cause and two ways to fix it.
T3. Message Queues
Intermediate · 45 min
Queues decouple producers from consumers: work is accepted fast, buffered, and processed asynchronously. They absorb spikes, enable fan-out, and add resilience — at the cost of new concerns like ordering, retries, and exactly-once delivery.
Skills: Async processing · Fan-out · At-least-once vs exactly-once · Backpressure
Build it: Redesign a slow synchronous "send email on signup" flow with a queue. What happens if the email worker is down for an hour?
T4. Consistent Hashing
Advanced · 45 min
Naive hashing (key % N) reshuffles almost everything when you add or remove a server. Consistent hashing places nodes and keys on a ring so a change moves only a small slice of keys — the trick behind distributed caches and databases.
Skills: The hash ring · Virtual nodes · Minimal reshuffling · Load balancing keys
Build it: With 4 cache nodes on a ring, add a 5th. Roughly what fraction of keys move, and why is that better than key % N?
T5. Rate Limiting
Intermediate · 45 min
To protect a service from abuse and overload you cap how fast callers can hit it. Token bucket, leaky bucket, and sliding window each shape bursts differently — and doing it across a fleet of servers needs shared state.
Skills: Token / leaky bucket · Sliding window · Distributed counters · Per-user vs global limits
Build it: Design a 100-requests-per-minute-per-user limit that works across 10 API servers. Where does the counter live?
T6. Consensus & Coordination
Advanced · 60 min
How do independent nodes agree on a single value — who is the leader, what is the latest committed write — despite failures? Consensus (Raft, Paxos) and coordination primitives (quorums, leader election) are the backbone of reliable distributed systems.
Skills: Leader election · Quorums (N/R/W) · Raft / Paxos intuition · Split-brain
Build it: With 5 replicas, pick read and write quorum sizes that guarantee strong consistency. Why does R + W > N matter?
Real Systems Design it
P1. Design a URL Shortener
Intermediate · 45 min
The classic warm-up. Generate short unique keys, store the mapping, and serve billions of read-heavy redirects with low latency. Simple on the surface, it exercises key generation, caching, and read/write scaling.
Skills: Key generation · Read-heavy scaling · Caching redirects · Base62 encoding
Build it: Walk the full design: how do you generate keys without collisions, and how do you serve a redirect in under 10ms at scale?
P2. Design a News Feed
Advanced · 60 min
Aggregating posts from everyone you follow, ranked, in milliseconds. The core decision is fan-out on write vs read, and the celebrity problem — a user with 50M followers breaks the naive approach.
Skills: Fan-out on write vs read · Feed ranking · The celebrity problem · Precomputation
Build it: Design the feed for a user following 500 accounts. When would you precompute the feed, and how do you handle a celebrity post?
P3. Design a Chat System
Advanced · 60 min
Real-time messaging with delivery guarantees, presence, ordering, and offline delivery. WebSockets vs long-polling, message storage, and the read-receipt problem make this a rich end-to-end design.
Skills: WebSockets & presence · Message ordering · Delivery guarantees · Offline queues
Build it: Design one-to-one chat: how does a message reach an offline user, and how do you guarantee it is delivered exactly once, in order?
P4. Design Twitter
Advanced · 60 min
The canonical large-scale interview problem. Timelines, tweets, follows, and serving hundreds of thousands of reads per second — it ties together fan-out, caching, sharding, and the hybrid push/pull timeline.
Skills: Timeline generation · Hybrid push/pull · Sharding tweets · Read-heavy scale
Build it: Design the home timeline. When do you push a tweet to followers vs pull on read, and how do you mix the two?
P5. Design a Video Platform
Advanced · 60 min
Upload, transcode, store, and stream video to millions — YouTube-scale. Chunked upload, transcoding pipelines, CDN delivery, adaptive bitrate, and metadata at scale come together here.
Skills: Chunked upload · Transcoding pipeline · CDN & adaptive bitrate · Metadata at scale
Build it: Trace a video from upload to playback: where does transcoding happen, and how does the CDN keep playback smooth on a bad connection?
P6. Design a Ride-Share
Advanced · 60 min
Matching riders to nearby drivers in real time — Uber-scale. Geospatial indexing, live location updates, matching, and surge pricing make this a demanding real-time systems problem.
Skills: Geospatial indexing (geohash/quadtree) · Real-time location · Matching · Surge pricing
Build it: Design driver matching: how do you find nearby drivers fast, and how do you keep millions of live locations fresh?