Free System Design Course  ·  46 Modules  ·  Beginner to Intermediate

Learn system design
from first principles.

We trace every byte from your keyboard to a server on the other side of the planet — and back. 46 interactive modules across two tracks. Zero cost. Zero fluff. The knowledge you need to design and explain real software systems.

Start Module 01 — Free → Browse all modules
46
Modules
36h
Total content
Free
Always
Beginner track · 20 modules

Everything you need.
In order.

The course is one progressive story — each module builds on the last. Start at Module 01 and work forward. The order matters.

M.01
What is a System?
Parts, atoms, and one HTTP request traced end-to-end
42 minLab
→ M.02
Client–Server
The asker and the answerer — and why the asymmetry exists
38 minLab
→ M.03
HTTP & HTTPS
Methods, headers, status codes, TLS — the whole picture
44 minLab
→ M.04
REST APIs
How services talk to each other — and what "RESTful" actually means
40 minLab
→ M.05
SQL vs NoSQL
When to use a relational database and when not to
46 min
→ M.06
Indexes & B-Trees
Why queries are fast — and why they sometimes aren't
42 minLab
→ M.07
Caching
Cache-aside, write-through, TTL, invalidation — all the patterns
48 minLab
→ M.08
Latency & Throughput
Measuring what matters — and how they trade off against each other
36 min
→ M.09
Scaling
Vertical vs horizontal — when to scale up and when to scale out
44 min
→ M.10
Load Balancing
Round-robin, least-connections, consistent hashing — and why it matters
42 minLab
→ M.11
DNS
How a hostname becomes an IP — the full resolver walk
38 minLab
→ M.12
CDNs
Edge servers, PoPs, cache-control — serving users faster worldwide
40 min
→ M.13
Statelessness
Why stateless servers scale and stateful ones don't
36 min
→ M.14
Auth
Sessions, JWTs, OAuth — how identity works across requests
50 minLab
→ M.15
Logging & Metrics
Observability — knowing what your system is doing in production
38 min
→ M.16
Reliability
SLAs, SLOs, redundancy, failover — building things that don't break
46 min
→ M.17
Build: URL Shortener
Design a production URL shortener — end-to-end architecture walk
55 minBuild
→ M.18
Build: Image App
Storage, CDN, processing pipelines — designing an Instagram-like system
55 minBuild
→ M.19
Reading Architecture Diagrams
Master the C4 model, sequence diagrams, ERDs, and spot diagram red flags
38 minLab
→ M.20
Interview Toolkit
The framework, vocabulary, and templates for any system design interview
60 min
→
Start at Module 01 → 42 min · no sign-up needed
Intermediate track · 26 modules

Beyond one machine.
Far beyond.

Finished the Beginner track? The Intermediate track picks up at Module 21: distributed state, event-driven architecture, microservices in practice, stream processing — capped by two full capstone designs and an interview toolkit.

M.21
CAP Theorem
One unavoidable trade-off — CP vs AP, and PACELC beyond it
42 minLab
→ M.22
Consistency Models
Linearizable to eventual — the spectrum your database lives on
45 minLab
→ M.23
Time, Order & Clocks
No shared clock — Lamport clocks, vector clocks, causality
45 minLab
→ M.24
Consensus & Raft
Leader election, log replication, quorums — agreement under failure
50 minLab
→ M.25
Replication Patterns
Single-leader, multi-leader, leaderless — and when each wins
45 minLab
→ M.26
Message Brokers
Kafka vs RabbitMQ — partitions, consumer groups, delivery guarantees
50 minLab
→ M.27
Pub/Sub Patterns
Fanout, topics, work queues, dead-letters — routing done right
40 minLab
→ M.28
Event Sourcing
Store events, not state — logs, projections, snapshots, replay
45 minLab
→ M.29
CQRS
Split reads from writes — and pay the eventual-consistency bill
40 minLab
→ M.30
Sagas & Distributed Transactions
Transactions without 2PC — compensation over rollback
45 minLab
→ M.31
Exactly-Once & Idempotency
At-least-once + idempotency + outbox = effectively once
50 minLab
→ M.32
Service Boundaries & DDD
Bounded contexts — deciding what should even be a service
50 minLab
→ M.33
API Gateways
One front door — routing, auth, rate limits, BFFs
45 minLab
→ M.34
Service Mesh
mTLS, retries, circuit breaking — in the sidecar, not your code
50 minLab
→ M.35
Service Discovery
Registries and health checks — addressing a fleet that keeps changing
45 minLab
→ M.36
Distributed Tracing
Trace IDs, spans, sampling — find the slow service in fifteen
50 minLab
→ M.37
Polyglot Persistence
The right store per context — and the cost of six databases
50 minLab
→ M.38
Inter-Service Communication
Sync vs async, orchestration vs choreography — the framework
55 minLab
→ M.39
Batch vs Stream
Bounded vs unbounded — Lambda, Kappa, and the core trade-offs
50 minLab
→ M.40
Windowing
Tumbling, sliding, session — slicing streams, handling lateness
55 minLab
→ M.41
Stateful Stream Processing
Checkpoints, state backends, savepoints — state that survives crashes
60 minLab
→ M.42
Change Data Capture
WAL, binlog, oplog — turning databases into streams
55 minLab
→ M.43
Real-Time Analytics
Streaming SQL vs real-time OLAP — sub-second dashboards
60 minLab
→ M.44
Build: Distributed K-V Store
The canonical capstone — consistent hashing to anti-entropy
70 minBuild
→ M.45
Build: Real-Time Analytics Platform
Compose the streaming stack into one platform — at three scales
75 minBuild
→ M.46
Interview Toolkit
Archetypes, capacity math, L4–L6 signals — the full framework
80 min
→
Explore the Intermediate track → 26 modules · ~22 hours · starts at Module 21
Why this course

Different by design.

◈

First principles, not patterns

We don't hand you a "design Twitter" template. We start with what a system actually is, and build from there. When you understand the primitives, every pattern becomes obvious.

⇌

Interactive where it counts

DNS resolution, TCP handshakes, cache hit/miss ratios — you step through simulations and watch the data move. Reading about it is not the same as seeing it.

▥

Zero fluff, zero paywall

No video intros. No 40-slide decks. No "premium tier." Every module is tight, dense, and free. We cut anything that isn't earning its place.

Start learning — it's free →