All Tracks
28 tracks covering distributed systems from foundations to advanced topics. Each track builds on concepts from previous ones.
Foundations
Core concepts and RPC fundamentals
The Messenger
Build the foundation of distributed communication. You will implement a Maelstrom node that handles JSON messages, processes initialization, and responds to echo requests. This track teaches the fundamental protocol that underlies all subsequent challenges.
The Identifier
Solve the fundamental problem of generating globally unique identifiers in a distributed system. You will implement various ID generation strategies, handle network partitions, and ensure uniqueness across nodes without centralized coordination.
The Gossiper
Implement efficient information propagation across a cluster. You will build broadcast protocols from basic flooding to optimized gossip with batching, learning how distributed systems share information without central coordination.
The Timekeeper
There are no global clocks in distributed systems. This track is about building the abstractions that replace them. You will explore physical time failures, implement Lamport clocks, vector clocks, and hybrid logical clocks.
The Networker
All distributed systems run on TCP. Building networking primitives from scratch makes everything else click. Implement TCP servers, message framing, serialization, and gRPC from first principles.
Consensus
Agreement protocols and distributed coordination
The Counter
Explore the challenges of maintaining consistent state across distributed nodes. You will encounter the lost update problem, implement CRDTs, and learn how distributed systems achieve convergence without coordination.
The Elector
Learn the fundamentals of distributed consensus through leader election. You will implement node states, heartbeats, randomized timeouts, and vote handling, building the foundation for the full Raft protocol.
The Consensus
Complete your Raft implementation with log replication. You will build log matching, commitment tracking, and apply entries to state machines, creating a fully functional consensus layer.
The Store
Build a linearizable key-value store on top of your Raft implementation. Handle client requests, manage sessions, ensure read consistency, and implement client retry logic.
Advanced
Complex distributed algorithms and paradigms
The Sharder
Implement horizontal scaling through sharding. Build shard controllers, consistent hashing, configuration changes, and data migration to create a scalable distributed storage system.
The Coordinator
Implement distributed transactions with two-phase commit, three-phase commit, and saga patterns.
Advanced
Explore advanced distributed systems topics: MapReduce for batch processing, distributed hash tables, Byzantine fault tolerance, and real-time stream processing.
The Orchestrator
Running 1000 services manually does not scale. Container orchestration automates the ops. Build pod scheduling, bin-packing, control loops, sidecar proxies, and service mesh concepts from scratch.
The Reactor
Instead of asking "what is the current state?", listen for "what just changed?" Build event sourcing, snapshots, projections, CQRS, and temporal queries from first principles.
The MapReducer
Process petabytes with simple map and reduce functions. Build single-machine and distributed MapReduce, shuffle phases, fault tolerance, streaming word counts, windowing, watermarks, and exactly-once processing.
Scalability
Horizontal scaling and performance patterns
Caches
Learn how caching improves read performance in distributed systems. Build request node caches, global caches, and distributed caches with consistent hashing. Master cache eviction and invalidation strategies.
Proxies
Build proxy servers that relay requests, deduplicate calls, and implement collapsed forwarding to reduce backend load. Learn how proxies serve as building blocks for scalable architectures.
Indexes
Build indexing systems for fast data retrieval in distributed storage. Implement hash indexes, B-Trees, LSM Trees, and secondary indexes. Learn how databases achieve efficient lookups at scale.
Load Balancers
Implement load balancing strategies to distribute traffic across backend servers. Build Layer 4 and Layer 7 balancers with health checking and various algorithms.
Queues
Build message queue systems for decoupling producers and consumers. Implement various delivery guarantees from at-most-once to exactly-once, learning the patterns that enable reliable asynchronous communication.
Storage
Distributed storage and data persistence
The Logger
The append-only log is the most fundamental data structure in distributed systems. Kafka, Raft, WAL, Zookeeper - all logs at heart. Build WALs, LSM Trees, B-Trees, and distributed logs.
The Filesystem
GFS and HDFS showed the world how to store petabytes across thousands of cheap machines. Build a tiny distributed filesystem with chunk servers, replication, and master failover.
Operations
Operational patterns and system management
The Scheduler
How does your system know which node should run which job - and what happens when that node dies? Build job queues, priority scheduling, cron systems, and distributed work allocation from scratch.
The Tracer
When something breaks at 3 AM in a system with 100 services, how do you find it in under 5 minutes? Build distributed tracing, metrics collection, time-series storage, and alerting systems.
The Securitor
Distributed systems have a larger attack surface. Security is not optional. Build mTLS, JWT authentication, RBAC, envelope encryption, key rotation, and audit logging from first principles.
The Migrator
Data outlives code. How do you change your data model without breaking running systems? Build migration runners, expand-contract patterns, API versioning, feature flags, and canary deployments.