distributed

Distributed Systems

What goes wrong when one system runs across many machines — and how they agree, stay available, and avoid making outages worse. Advanced; comfortable with one backend first.

9 units·46 lessons·~41 h

Start track →

00

Start from zero

Before the senior material: what a distributed system even is, and the handful of words the rest of the track assumes you already know.

01 Start from zero: what a distributed system actually is 10 min

01

Cap practice

Coming soon — Distributed systems in practice

01 CAP in practice: consistency vs availability during inevitable partitions 15 min 02 CAP in practice: multiple-choice review 13 min 03 CAP in practice: free-recall review 13 min 04 CAP in practice: config and scenario reading 14 min 05 CAP in practice: build and partition a replicated store 240 min

02

Raft consensus: leader election, log replication, and production operations

How three to seven machines agree on exactly one ordered log — leader election, AppendEntries, quorum commits, pre-vote, snapshots, and the ops discipline that keeps a Raft cluster alive in production.

01 Raft roles, terms, and why majority quorums prevent split brain 10 min 02 How Raft replicates a log entry and decides it is safe to commit 14 min 03 Raft leader election: timeouts, voting rules, and the four safety properties 14 min 04 Raft in the real world: partitions, slow disks, and client routing 12 min 05 Raft extensions: pre-vote, learners, snapshots, and linearizable reads 16 min 06 Raft in production: membership changes, Multi-Raft, and observability 16 min 07 Raft: multiple-choice review 14 min 08 Raft: free-recall review 14 min 09 Raft: code and log reading 14 min 10 Raft: build and break a cluster 240 min

03

Quorum

Coming soon — Distributed systems in practice

01 Quorums: the R + W > N invariant and how it quietly breaks 16 min 02 Quorums: multiple-choice review 13 min 03 Quorums: free-recall review 14 min 04 Quorums: config and code reading 14 min 05 Quorums: build a tunable-consistency store 240 min

04

Leader election

Coming soon — Distributed systems in practice

01 Leader election: one writer, terms, and the split-brain that fencing tokens stop 17 min 02 Leader election: multiple-choice review 13 min 03 Leader election: free-recall review 13 min 04 Leader election: code and log reading 14 min 05 Leader election: build a fenced single-writer 240 min

05

Clocks

Coming soon — Distributed systems in practice

01 Time and ordering: why wall-clock timestamps lie 17 min 02 Clocks: multiple-choice review 13 min 03 Clocks: free-recall review 13 min 04 Clocks: code and trace reading 14 min 05 Clocks: build a conflict-detecting store 240 min

06

Sagas

Coming soon — Distributed systems in practice

01 Sagas: long-lived transactions across services without 2PC 16 min 02 Sagas: multiple-choice review 13 min 03 Sagas: free-recall review 14 min 04 Sagas: code reading 14 min 05 Sagas: build a fault-tolerant order saga 240 min

07

Retry amplification

Coming soon — Distributed systems in practice

01 Retry amplification: how 3 retries per layer becomes a metastable outage 17 min 02 Retry amplification: multiple-choice review 13 min 03 Retry amplification: free-recall review 13 min 04 Retry amplification: code reading 14 min 05 Retry amplification: break a metastable storm 240 min

08

Putting it together

Coming soon — Distributed systems in practice

01 Putting it together: an order pipeline where the seams leak 17 min 02 Distributed capstone: multiple-choice review 13 min 03 Distributed capstone: free-recall review 14 min 04 Distributed capstone: code and config reading 14 min 05 Distributed capstone: design a fault-tolerant pipeline 240 min

Build with this track

Guided projects that exercise what you learn here.

At-least-once job queue

Build a durable job queue on Postgres with visibility timeouts and idempotent consumers, so a crashed worker never drops a job.

Circuit breaker

Build a circuit breaker that stops hammering a failing dependency, probes it safely with a half-open state, and resets automatically — the exact pattern that keeps microservice cascades from turning one bad node into a full outage.

Collaborative cursors

Show every connected user's live cursor and selection in a shared document, conflict-free, over WebSocket.

Consistent hashing ring

Build a virtual-node hash ring that remaps only the minimum set of keys when a node joins or leaves — the foundational primitive behind Dynamo, Cassandra, and every sharded cache that must survive node churn without a full reshuffle.

Job scheduler

A cron + backoff job runner with at-least-once delivery, idempotent handlers, and visibility timeouts — so no job is silently lost even when workers crash mid-execution.

Offline PWA sync

Offline-first notes PWA: a local write queue (IndexedDB) that syncs on reconnect with last-writer-wins conflict resolution, a service worker for asset caching, and background sync for missed flushes.

Distributed rate limiter

Build a token-bucket limiter that holds across many app instances by keeping the counter in Redis, not in process memory.

Union-Find (Disjoint Set Union)

Build a disjoint-set structure from a naive parent array up to near-constant amortized time — then use it to drive Kruskal's MST algorithm on a weighted graph.

Crash-safe key-value store with a WAL

Build a tiny on-disk KV store that survives a kill -9 mid-write by appending to a write-ahead log before touching the main file.

Security

The ways real apps get attacked and how to defend them — safe login and sessions, validating input, and the common mistakes that leak data.