Learning track · 26 concepts
System Design
Architecture-level thinking: low-level design, scalability, distributed systems, event-driven design, and end-to-end case studies.
What mastery looks like
This track contains 26 connected concepts rather than an unordered reading list. Mastery means you can move from vocabulary to mechanisms, predict how the system behaves under pressure, and support a design decision with code, measurements, or a failure-recovery exercise. For System Design, use the track description as the boundary: learn enough detail to reason clearly about architecture-level thinking: low-level design, scalability, distributed systems, event-driven design, and end-to-end case studies.
A useful explanation names the state involved, the operation that changes it, the resource or safety constraint, and the observable signal that tells you whether the mechanism works. Avoid stopping at product names. Compare at least two approaches, state what each optimizes, and identify what breaks first as scale, concurrency, latency, or uncertainty increases.
Suggested study sequence
Start with the core concepts at the top of the list and write a one-paragraph mechanism note for each. Continue through the core concepts by alternating explanation with an executable drill. Treat Concurrency Design, Booking & Inventory, Consistent Hashing, Consensus as integration work: they should combine earlier mechanisms rather than introduce disconnected facts.
At the end of each session, record one decision you can now make, one failure mode you can now predict, and one unanswered question. Revisit that question through the linked primary sources, then prove the answer in the Playground or a real repository. The track is complete when you can transfer the reasoning to an unfamiliar system, not when every page has been opened.
Roadmaps
Concepts in this track
core
Object Modeling
Identifying classes, attributes, relationships.
core
State Machines
States, transitions, guards.
core
Strategy Pattern
Interchangeable algorithms.
core
Observer Pattern
Pub/sub, event propagation.
core
Factory & Creational
Abstract factory, builder, singleton.
core
Decorator & Structural
Decorator, adapter, composite.
advanced
Concurrency Design
Thread-safety, locks, producer-consumer.
core
Command & Chain
Command, undo, chain of responsibility.
advanced
Booking & Inventory
Reservation, hold-confirm, optimistic locking.
core
Game/Simulation Design
Turn engines, board state, rules.
core
Load Balancing
L4/L7, consistent hashing, health checks.
advanced
Consistent Hashing
Ring, virtual nodes, rebalancing.
advanced
Consensus
Raft, Paxos, leader election.
advanced
Distributed Infra
Service discovery, orchestration.
core
Real-time Systems
WebSockets, server-sent events, presence, synchronization, ordering, reconnects, optimistic UI, and conflict handling.
core
Feed Systems
Fan-out write/read, timeline.
core
Streaming Media
CDN, HLS, transcoding pipeline.
core
Geo Systems
Geohash, quadtree, dispatch.
advanced
Collaboration Systems
OT, CRDT, conflict resolution.
advanced
Search Platform Design
End-to-end design of a search platform: ingestion, indexing, query, ranking.
advanced
RAG System Design
Architecting a production RAG system: ingestion, retrieval, generation, evals.
core
Capacity Estimation
Back-of-the-envelope QPS, storage, and bandwidth maths that sizes a design before you draw it.
core
Requirements Scoping
Separating functional from non-functional requirements and cutting scope to something buildable.
core
Rate Limiter Design
Token bucket versus sliding window, and making a limiter work across many nodes.
core
Unique ID Generation
Snowflake, ULID, and UUIDv7 — unique ids without a central allocator.
core
CDN & Edge Delivery
Cache hierarchy, origin shield, and invalidation versus TTL at the edge.