Learn system design from first principles.

The asker and the answerer — and why the asymmetry exists

→ M.02

Client–Server

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

Cache-aside, write-through, TTL, invalidation — all the patterns

→ M.07

Caching

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

How a hostname becomes an IP — the full resolver walk

→ M.11

DNS

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

Observability — knowing what your system is doing in production

→ M.15

Logging & Metrics

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

Linearizable to eventual — the spectrum your database lives on

→ M.22

Consistency Models

No shared clock — Lamport clocks, vector clocks, causality

→ M.23

Time, Order & Clocks

Leader election, log replication, quorums — agreement under failure

→ M.24

Consensus & Raft

Single-leader, multi-leader, leaderless — and when each wins

→ M.25

Replication Patterns

Kafka vs RabbitMQ — partitions, consumer groups, delivery guarantees

→ M.26

Message Brokers

Fanout, topics, work queues, dead-letters — routing done right

→ M.27

Pub/Sub Patterns

40 minLab

→ M.28

Event Sourcing

Store events, not state — logs, projections, snapshots, replay

Split reads from writes — and pay the eventual-consistency bill

→ M.29

CQRS

40 minLab

→ M.30

Sagas & Distributed Transactions

Transactions without 2PC — compensation over rollback

Exactly-Once & Idempotency

→ M.31

At-least-once + idempotency + outbox = effectively once

Bounded contexts — deciding what should even be a service

→ M.32

Service Boundaries & DDD

One front door — routing, auth, rate limits, BFFs

→ M.33

API Gateways

mTLS, retries, circuit breaking — in the sidecar, not your code

→ M.34

Service Mesh

Registries and health checks — addressing a fleet that keeps changing

→ M.35

Service Discovery

Trace IDs, spans, sampling — find the slow service in fifteen

→ M.36

Distributed Tracing

The right store per context — and the cost of six databases

→ M.37

Polyglot Persistence

Inter-Service Communication

→ M.38

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

Tumbling, sliding, session — slicing streams, handling lateness

→ M.40

Windowing

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

Expert track · 27 modules

Underneath the systems.
And beyond them.

The depth track. Consensus proofs, storage and query engine internals, hardware, formal verification, ML systems — then the production disciplines that define staff-level work: observability, chaos, multi-tenancy, DR, FinOps, platform engineering, privacy.

M.47

Paxos & Consensus

Prepare/accept, proposal numbers, Multi-Paxos — the protocol under quorums

Byzantine Fault Tolerance

→ M.48

3f+1 replicas, PBFT's three phases — surviving nodes that lie

Clock skew, vector clocks, HLC, TrueTime's uncertainty interval

→ M.49

Time & Causality

85 minLab

→ M.50

Linearizability & Consistency

What vendors blur when they say “strong consistency”

2PC's blocking problem, Percolator, Spanner's 2PC-over-Paxos

→ M.51

Distributed Transactions

Geo-Distributed Transactions

→ M.52

Commit-wait, HLC read restarts, Calvin — transactions at light speed

B+ trees vs LSM trees, compaction, amplification trade-offs

→ M.53

Storage Engine Internals

Cache lines, false sharing, NUMA, NVMe, kernel bypass

→ M.54

Hardware-Aware Design

Specifying, model checking, and proving absence of design bugs

→ M.55

Formal Methods & TLA+

Framing, multiplexing, congestion control — and why QUIC exists

→ M.56

Custom Network Protocols

Planning, cost-based optimization, vectorized execution

→ M.57

Query Engine Internals

HNSW, IVF, product quantization — recall vs latency vs memory

→ M.58

Vector Databases & ANN

Inverted indexes, BM25, analysis, multi-stage reranking

→ M.59

Search Engine Internals

Gorilla compression, downsampling — and the cardinality ceiling

→ M.60

Time-Series Databases

Exactly-once end to end, backpressure, reprocessing

→ M.61

Streaming Architectures

Delta, Iceberg, Hudi — ACID and time travel on object storage

→ M.62

Data Lakehouse

Domain ownership, data as product, enforceable contracts

→ M.63

Data Mesh & Contracts

Data/tensor/pipeline parallelism, ZeRO and FSDP sharding

→ M.64

Distributed ML Training

Inference Serving at Scale

→ M.65

PagedAttention, continuous batching, speculative decoding

Cardinality budgets, sampling, exemplars, eBPF

→ M.66

Observability at Scale

Steady-state hypotheses, blast radius, game days

→ M.67

Chaos Engineering

Silo/pool/bridge isolation, noisy neighbors, cost attribution

→ M.68

Multi-Tenant SaaS

RTO and RPO — from backup-restore to active-active

→ M.69

Disaster Recovery

Cost Optimization & FinOps

→ M.70

Unit economics, commitments, spot, tiering, egress traps

Platform Engineering & IDPs

→ M.71

Golden paths, platform as product, DORA metrics

Data Privacy & Compliance

→ M.72

PII discovery, GDPR deletion, lineage, residency, consent