The theory of systems that span multiple machines — why they’re fundamentally hard, and the algorithms that tame the hardness. The hardest and most foundational material in the Architecture course, and exactly what the build-your-own Redis / DB / Raft-KV projects need.
Source: roadmap.sh has no distributed-systems roadmap, so this is from the canon — Kleppmann’s Designing Data-Intensive Applications, MIT 6.824, and the primary papers (Lamport, FLP, CAP/Gilbert-Lynch, Raft, Spanner). [reference] — deep theory to study and build; you won’t fully grasp it without implementing (esp. Raft).
A deep curriculum, grouped into five parts. Every note opens with a plain-language “kid version first” intuition before going to full depth, and ends with a Key insight. Read A→C, then build a Raft KV-store, then D→E.
Part A — Foundations (the models & limits)
- What Makes It Hard — [Advanced] — partial failure, the failure/timing/clock models, process pauses, why perfect failure detection is impossible, safety vs liveness, the 8 fallacies
- Theoretical Limits — [Advanced] — Two Generals, FLP, CAP → PACELC, the consistency/latency tradeoff, CALM
- Time & Ordering — [Advanced] — happens-before, Lamport & vector clocks (worked traces), Hybrid Logical Clocks, TrueTime
Part B — Consistency & Replication
- Consistency Models — [Advanced] — linearizable → sequential → causal → eventual, session guarantees, the cost of strong consistency
- Replication — [Advanced] — leader / multi-leader / leaderless, quorums, read-repair, anti-entropy, the Dynamo lineage
- CRDTs & Conflict Resolution — [Advanced] — LWW, state/op CRDTs, causal merge, version vectors, where it’s used
Part C — Consensus
- Consensus & Paxos — [Advanced] — why agreement is hard, Paxos & Multi-Paxos, quorums, where it’s used (etcd, ZooKeeper)
- Raft in Depth — [Advanced] — RPCs field-by-field, log matching, the Figure-8 commitment rule, membership changes, snapshots, linearizable client sessions, ReadIndex
- Coordination Services — [Advanced] — ZooKeeper/etcd, leases, fencing tokens, VR/ZAB, BFT/PBFT
Part D — Transactions & Storage
- Distributed Transactions — [Advanced] — 2PC/3PC, isolation levels, MVCC, the saga pattern, idempotency
- Modern Distributed Transactions — [Advanced] — Spanner/TrueTime, Percolator, Calvin, CockroachDB
- The Log & State Machines — [Advanced] — replicated state machines, Kafka, LSM-trees, CDC, event sourcing
Part E — Partitioning & Operations
- Partitioning — [Advanced] — sharding strategies, consistent hashing, rebalancing, hotspots
- Failure Detection & Membership — [Advanced] — heartbeats, phi-accrual, gossip, SWIM, anti-entropy, split-brain
- Testing Distributed Systems — [Advanced] — Jepsen, deterministic simulation, chaos, TLA+
How to actually learn this
Reading isn’t enough here — distributed systems reward implementation more than any other topic in the vault. The path that sticks: read Part A–C, then build a Raft KV-store — the full build guide is Your Own Raft Key-Value Store, and the case studies are the systems that did it for real. It forces every consensus edge case to become real. Then the transactions / storage / ops parts land, because you’ve felt why they’re hard.
Related
- Databases — the single-node view: MVCC, WAL, and the operator’s side of replication and sharding
- CAP & Consistency — the fundamentals-level view of what this section proves
- Concurrency (Java) — the single-machine version of many of these problems
- Case Studies — the build-your-own projects that make this real
- Your Own Raft Key-Value Store — the build guide for this whole section: election, replication, the commit rule, and deliberate partitions
Software engineering
Infrastructure & security
Computer science
Hardware & engineering