You end up withNodes you wrote that pass Jepsen's Maelstrom tests for broadcast, a grow-only counter, a Kafka-style replicated log and a transactional key-value store under injected network failures; a Raft implementation with leader election and log replication under a key-value store; and a TLA+ specification that finds a design bug before any code does.
Data pulled 2026-11-08 · time estimates are editorial
Why build distributed systems when the cloud sells them as a service? Because you already run one: any app with a database, a cache and a queue is a distributed system, and its worst bugs come from messages that arrive twice, late or never. After this track, partitions, retries and leader elections are things you’ve made fail and fixed.
This course is an opener. Its first three stages are published. More stages come next; see Coming next at the end.
How to read the receipts.
Points are summed across every HN submission of the same URL. For sites with many pages (the Raft site, MIT’s course pages, Learn TLA+), that includes pages submitted on their own.
“Submitted N×” means HN rediscovered it N times.
Quotes come from the highest-ranked top-level comments in those threads, and a quote is sometimes a criticism. Quotes keep the commenter’s spelling.
Steps are ordered for learning, not by points.
Times are our estimates, not the authors’. They assume evenings and weekends, and a reader who writes Go or another language comfortably. Stage 1’s instructions are in Go, but Maelstrom accepts nodes in any language.
Hard-won advice for engineers new to distributed systems, written as a list of lessons: coordination is very hard, “it’s slow” is the hardest problem you’ll ever debug, implement backpressure, find ways to be partially available, use percentiles not averages, and use the CAP theorem to critique systems. Read it before the code, and again after.
“I share this doc with the most promising people I get to work with.”
HN’s addition: “One that is not mentioned here but that I like as a general principle is that you cannot have exactly once delivery.” (sulam, 2024 · comment). You’ll meet that limit in Stage 1’s broadcast challenge.
https://github.com/jepsen-io/maelstrom · 540 points across 10 submissions of the challenges and of Maelstrom (2017–2026) · Free · Go, or any language · ~3–5 weeks
Six challenges, each a small node you write that Maelstrom runs as a cluster, sends traffic to over a simulated network, breaks with partitions and delays, and checks for the guarantee the challenge asks for: echo, unique ID generation, broadcast by gossip, a grow-only counter, a Kafka-style replicated log, and totally-available transactions. Maelstrom is built by Kyle Kingsbury on Jepsen, the tool behind his published database failure analyses, so a failing test usually points at a real kind of bug.
“Love it. Thanks for putting this together! The actual challenges here [0].”
HN’s caveat is setup. Maelstrom is a Clojure program that runs on the JVM, and the Go instructions tripped some people up: “Dockerfile would be a really good idea.” (yodelshady, 2023 · comment). Install a recent JDK first. If you get stuck, the challenge page points to the #dist-sys-challenge tag on the Fly.io community forum. Maelstrom’s own guide covers similar ground in more depth, ending with a chapter on Raft.
https://raft.github.io/ · 1,762 points across 48 submissions of the visualization and the Raft site (2014–2025) · Free · ~1 week
Start with the animated walkthrough of leader election and log replication, then read the paper, In Search of an Understandable Consensus Algorithm, linked from the Raft site. The paper was written to be taught, and its Figure 2 summarizes the whole algorithm on one page; keep it open for step 3.
Leader election and log replication in about 1,000 lines of Go, with a key-value store on top that you query over HTTP. Kill a server and restart it, and a new leader is elected with the data intact. Reconfiguration and snapshotting are left out. The author took about seven months of sporadic study to get there, and tested it manually and with automated tests, not yet with Jepsen.
“The author spent 7 months tinkering and cared enough to come back and share that with us.”
HN’s caveat is the one every Raft implementer feels: “I experimentally implemented Raft in Java but I am not very confident that I did it correctly.” (samsquire, 2023 · comment). The author’s own disclaimer reads “I’m not an expert.” Test under failure, not just on the happy path, and Stage 3 shows another way to gain confidence.
Alternative: the labs of MIT’s 6.5840 Distributed Systems (formerly 6.824; 469 points across 13 submissions of its pages, mostly its course notes) build MapReduce, a key/value server, Raft, a key/value service on Raft, and a sharded key/value store, in Go, with lectures on YouTube. Harder, and with a far more thorough test suite.
TLA+ lets you write a design as a precise specification and have a model checker try every interleaving of it, which finds the race that only happens one time in a million. This guide teaches it to programmers: core TLA+, plus PlusCal, a pseudocode-like language that compiles to TLA+, with worked examples. Model one of your Stage 1 or Stage 2 designs and see what it finds.
“In my experience, writing a formal specification once in TLA+ has shaped my mindset around architecture, implementation, and verification of distributed systems for the last 19 years.”
Alternative: Leslie Lamport’s own TLA+ Video Course (682 points, submitted 10×), from the inventor of TLA+.
Coming next
Candidates for the next stages, receipts pulled but not yet reviewed or written:
CRDTs and local-first data. crdt.tech (455 points) and Martin Kleppmann’s CRDTs: The Hard Parts (419 points).
A replicated log. Tyler Treat’s Building a Distributed Log from Scratch series (794 points).
Paxos and consistency models.Neat Algorithms: Paxos (343 points), How you could have come up with Paxos yourself (228 points), and Jepsen’s consistency models map (274 points).
The reference shelf
Designing Data-Intensive Applications · Martin Kleppmann · https://dataintensive.net/ · 610 points, submitted 6× (2014–2025) · Paid book (O’Reilly). The standard survey of how data systems replicate, partition and agree, and what each trade-off costs. “It will not appeal to the absolute novice to be sure.” (wenc, 2017 · comment)
Distributed systems for fun and profit · Mikito Takada · http://book.mixu.net/distsys/ · 557 points, submitted 17× (2013–2026) · Free. A short free book on the same ideas, from 2013: time and order, replication, and weak consistency.
Editorial backlog
Checked against HN on 2026-11-08 (candidates_receipts.json), not used:
Distributed Systems Reading List (Dan Creswell, 766 points) and A distributed systems reading list (Fred Hebert, 369 points): lists, not paths. Of the first: “Turns out this list is from 2014 [1], reader beware, as things have changed since then.” (npalli, 2024 · comment)
Martin Kleppmann’s Cambridge distributed systems lectures (83 points): a free lecture course that would suit a theory stage.
Method
Candidates came from the 38 distributed-tagged stories in the 4,140-story pull, plus a distributed topic pull with 27 terms: 305 candidates in all (phase1-stories/data/distributed_candidates.json). Jepsen’s individual database analyses, CRDT product launches and unrelated “raft” and “Paxos” (the company) stories made up much of the noise and were skipped by hand.
Exclusions. Papers by other authors hosted in MIT 6.824’s readings folder (the Raft paper, Go’s memory model, a joke paper) are not counted toward the course: 3 submissions, 81 points.
Selection. 20 resources had receipts pulled; 11 are used here, chosen by hand for followability and sequence. Points were then totalled across every submission of each URL.
Quotes come from the top five top-level comments of the two best-scoring threads per resource, in HN’s ranked order via the Firebase API. Links go to the full comment. Every ID and quote is checked with phase1-stories/scripts/check_track.py.
Content and costs were checked on 2026-11-08 on each resource’s own page: the six Gossip Glomers challenges and their Go documentation, Maelstrom’s README and guide chapters, the scope and size of Phil Eaton’s Raft post, the 6.5840 Spring 2026 page, and the Learn TLA+ work-in-progress notice. Time estimates are editorial, not measured.
Data:tracks/distributed/receipts.json (resources used) and candidates_receipts.json (all 20 checked).