Free lesson · System Design Fundamentals
Course Roadmap
Lesson 1.2 - Course Roadmap
The second lesson of Module 1.
This is the map. Thirty modules, a hundred and seventy-six lessons, organized into seven stretches that each build on the last. Some stretches are conceptual (core concepts, trade-offs, distributed fundamentals). Some are deep dives into specific technologies (PostgreSQL, Redis, Kafka, S3). Some are operational (deployment, observability, security). Together they cover the full landscape of modern system design.
You don't need to memorize this roadmap. Come back to it when you want to see where you are and what's ahead.
The Journey
Interactive animation: The whole course on one map: seven stretches, thirty modules.
flowchart TD
S1["Stretch 1: Foundations<br/>M1-M3 · 20 lessons"]
S2["Stretch 2: Traffic & APIs<br/>M4-M9 · 29 lessons"]
S3["Stretch 3: Caching & CDNs<br/>M10-M11 · 11 lessons"]
S4["Stretch 4: Data & Storage<br/>M12-M17 · 27 lessons"]
S5["Stretch 5: Distributed Systems<br/>M18-M22 · 28 lessons"]
S6["Stretch 6: Architecture at Scale<br/>M23-M26 · 38 lessons"]
S7["Stretch 7: Running It<br/>M27-M30 · 23 lessons"]
S1 --> S2 --> S3 --> S4 --> S5 --> S6 --> S7
style S1 fill:#34d399,stroke:#10b981,color:#000
style S4 fill:#fbbf24,stroke:#f59e0b,color:#000
style S5 fill:#a78bfa,stroke:#8b5cf6,color:#000
style S7 fill:#fb7185,stroke:#f43f5e,color:#000
A vertical flow diagram showing the seven stretches of the course. Stretch one is Foundations - modules one to three, twenty lessons, covering orientation, core concepts, and networking. Stretch two is Traffic and APIs - modules four to nine, twenty-nine lessons, covering load balancing, API design, API infrastructure, API security, real-time communication, and asynchronous communication. Stretch three is Caching - modules ten and eleven, eleven lessons, covering caching fundamentals and distributed caching. Stretch four is Data and Storage - modules twelve to seventeen, twenty-seven lessons, covering database fundamentals, database types, database internals, scaling reads, scaling writes, and storage systems. Stretch five is Distributed Systems - modules eighteen to twenty-two, twenty-eight lessons, covering key trade-offs, distributed fundamentals, time and ordering, coordination and consensus, and distributed transactions. Stretch six is Architecture at Scale - modules twenty-three to twenty-six, thirty-eight lessons, covering data structures for scale, architectural patterns, microservices patterns, and big data processing. Stretch seven is Running It - modules twenty-seven to thirty, twenty-three lessons, covering deployment strategies, release patterns, observability, and security fundamentals.
Stretch-by-Stretch Overview
Interactive animation: Why the order matters: each stretch is built on the one before it.
Stretch 1: Foundations (M1-M3) - "The vocabulary everything else assumes"
Orientation, then the core system design vocabulary (scalability, availability, reliability, single points of failure, latency versus throughput, consistent hashing, CAP), then networking fundamentals - TCP, HTTP, DNS, the plumbing underneath everything.
Milestone: After M3, you can trace a request from a browser to a server and back, and you have the words for the trade-offs the rest of the course keeps returning to.
Stretch 2: Traffic & APIs (M4-M9) - "How systems talk to each other"
Load balancing first (one address, many machines), then API design (REST, GraphQL, gRPC), API infrastructure (gateways, rate limiting), API security (JWT, OAuth, SSO), real-time communication (WebSockets, SSE), and asynchronous communication (queues, pub/sub, delivery semantics).
Milestone: After M9, you can design an API for a service, secure it, put a load balancer in front of it, and choose correctly between a synchronous call and a queue.
Stretch 3: Caching (M10-M11) - "How you make things fast"
Caching fundamentals (cache-aside, read-through, write-behind, eviction, invalidation, CDNs), then distributed caching - Redis, Memcached, and the problems that only appear once the cache itself is spread across machines.
Milestone: After M11, you can decide where to place a cache, which pattern to use, and how to handle the hard parts - invalidation, stampede, and consistency.
Stretch 4: Data & Storage (M12-M17) - "Where the data lives"
Database fundamentals, then database types in depth (relational, document, wide-column, search, graph, time-series, vector), database internals (B-trees, LSM trees), scaling reads (indexing, replicas), scaling writes (sharding, partitioning), and finally storage systems - block, file, and object storage.
Milestone: After M17, you can choose the right database for a workload, explain why, and describe how it scales in both directions. Slow down here; it pays back more than any other stretch.
Stretch 5: Distributed Systems (M18-M22) - "The hard problems"
The conceptual heart of the course. Key trade-offs named explicitly, then why distributed systems are categorically harder, time and ordering (Lamport timestamps, vector clocks), coordination and consensus (ZooKeeper, Paxos, Raft, CRDTs), and distributed transactions (two-phase commit, sagas).
Milestone: After M22, you can reason about the correctness of a distributed system - what it guarantees, what it gives up, and which coordination mechanism buys which guarantee.
Stretch 6: Architecture at Scale (M23-M26) - "The shapes that recur"
The largest stretch by lesson count. Data structures for scale (Bloom filters, HyperLogLog, geohash, Merkle trees, skip lists and more), architectural patterns (monolith versus microservices, event-driven, CQRS, event sourcing), microservices patterns (service discovery, gateway, sidecar, strangler fig, service mesh), and big data processing (Kafka, batch and stream).
Milestone: After M26, you can discuss architecture at the system level, reach for the right specialized data structure by name, and design a pipeline from event to storage.
Stretch 7: Running It (M27-M30) - "Surviving Tuesday"
Most courses stop at the architecture. This one keeps going: deployment strategies (CI/CD, rolling, blue-green), release patterns (canary, feature flags, A/B testing, schema migrations, rollbacks), observability (metrics, logs, traces, SLOs), and security fundamentals (TLS, encryption, secrets, RBAC).
Milestone: After M30, you have the complete vocabulary. You can design, deploy, monitor, secure, and defend a production system.
Pacing Guide
Interactive animation: What it actually takes, in lessons and months.
The useful unit here is lessons, not modules - the modules vary a lot in size, from two lessons to twelve.
| Pace | Lessons/day | Total time | Best for |
|---|---|---|---|
| Intensive | 2-3 | ~2-3 months | Full-time interview prep |
| Steady | 1 | ~6 months | Working engineers, evenings + weekends |
| Relaxed | 3-4 per week | ~10-12 months | Deep absorption, no rush |
One lesson a day is what I recommend. A hundred and seventy-six lessons at one a day finishes in about six months, and it is a pace you can actually hold. Consistency beats intensity here, and it is not close.
What's Next
Lesson 1.3 introduces the AlgoInsight community - Discord, study groups, and how to get help when you're stuck.