System Design Learning Path — 12-Week Intensive Curriculum

• Chapter 1: Scale from Zero to Millions of Users (Alex Xu)
• Chapter 1: Reliable, Scalable, and Maintainable Applications (DDIA)
• Video: How Discord Stores TRILLIONS of Messages
• Project: Build a simple Node.js + Redis app with horizontal scaling
• Blog: Primary or alternative topic

Covers scaling from single server to millions of users, reliability (faults, durability), scalability (load, growth), and maintainability. Introduces how systems like Discord store and serve massive message volumes and how to scale a simple app with Redis.

• Chapter 2: Back-of-the-envelope Estimation (Alex Xu)
• Chapter 2: Data Models and Query Languages (DDIA)
• Video: Big-O Notation in 100 Seconds (Fireship)
• Project: Run capacity planning for your own app; try SQL and Postgres
• Blog: Primary or alternative topic

Covers quick capacity estimates (QPS, storage, bandwidth), Big-O thinking, and data modeling: relational vs document vs graph models, query languages, and when to use SQL vs NoSQL. You’ll apply this with real capacity planning and Postgres.

• Chapter 3: A Framework for System Design Interviews (Alex Xu)
• Chapter 3: Storage and Retrieval (DDIA)
• Video: System Design Interview Basics (ByteByteGo)
• Project: Answer a mock interview question (e.g. Design a URL shortener)
• Blog: Primary or alternative topic

Covers a step-by-step framework for system design interviews (requirements, scale, APIs, data model, bottlenecks) and how databases store and retrieve data: indexes, B-trees, LSM-trees, and trade-offs. You’ll practice with a classic URL shortener-style question.

• Chapter 4: Design a Rate Limiter (Alex Xu)
• Chapter 4: Encoding and Evolution (DDIA)
• Video: Rate Limiting (Fireship)
• Project: Implement a token-bucket rate limiter in Node.js or Python
• Blog: Primary or alternative topic

Covers designing rate limiters (token bucket, sliding window, distributed limits) and data encoding/evolution: JSON, Protobuf, Avro, schema evolution, and backward compatibility. You’ll build a working rate limiter and see how APIs protect against abuse.

• Chapter 5: Design Consistent Hashing (Alex Xu)
• Chapter 5: Replication (DDIA)
• Video: Consistent Hashing (Gaurav Sen)
• Project: Simulate consistent hashing with a simple ring
• Blog: Primary or alternative topic

Covers consistent hashing for distributed caches and databases (minimizing rebalancing when nodes join/leave) and replication: leader-follower, sync vs async, replication lag, and failover. You’ll implement a ring and see how systems like Dynamo/Cassandra use it.

• Chapter 6: Design a Key-Value Store (Alex Xu)
• Chapter 6: Partitioning (DDIA)
• Video: Database Sharding Explained (Fireship)
• Project: Build a tiny key-value store with partitioning logic (Python or Go)
• Blog: Primary or alternative topic

Covers designing a distributed key-value store (CAP, consistency, storage layout) and partitioning/sharding: key-range vs hash-based partitioning, rebalancing, and handling hot keys. You’ll build a minimal KV store with partition logic.

• Chapter 7: Design a Unique ID Generator (Alex Xu)
• Chapter 7: Transactions (DDIA)
• Video: UUID vs. Snowflake IDs
• Project: Implement Twitter Snowflake IDs in Node.js or Python
• Blog: Primary or alternative topic

Covers generating unique IDs at scale (UUID, Snowflake, segment-based) and transactions: ACID, isolation levels, and distributed transactions. You’ll implement Snowflake-style IDs and understand when to use them vs UUIDs.

• Chapter 8: Design a URL Shortener (Alex Xu)
• Chapter 8: The Trouble with Distributed Systems (DDIA)
• Video: How Bitly Works (Systems Design)
• Project: Build a working URL shortener with database and base62 encoding
• Blog: Primary or alternative topic

Covers designing a URL shortener (hash, encoding, redirects, scaling) and the pitfalls of distributed systems: faults, unreliable networks, clock skew, and Byzantine failures. You’ll build a shortener and understand why distributed systems are hard.

• Chapter 9: Design a Web Crawler (Alex Xu)
• Chapter 9: Consistency and Consensus (DDIA)
• Video: How Search Engines Crawl the Web
• Project: Write a basic web crawler (Python + Scrapy or Beautiful Soup)
• Blog: Primary or alternative topic

Covers designing a web crawler (politeness, dedup, frontier, scale) and consistency/consensus: linearizability, Raft, Paxos, and when strong consistency is worth the cost. You’ll build a crawler and see how consensus keeps replicas in sync.

• Chapter 10: Design a Notification System (Alex Xu)
• Chapter 10: Batch Processing (DDIA)
• Video: Push Notifications at Scale (Netflix)
• Project: Set up a simple push-notification service with FCM or RabbitMQ
• Blog: Primary or alternative topic

Covers designing a notification system (push vs pull, channels, fan-out) and batch processing: MapReduce, data pipelines, and how systems like Hadoop process large datasets. You’ll build a small notification service and see how Netflix scales push.

• Chapter 11: Design a News Feed System (Alex Xu)
• Chapter 11: Stream Processing (DDIA)
• Video: How Instagram's Feed Works
• Project: Build a mini feed aggregator (fanout-on-write or fanout-on-read)
• Blog: Primary or alternative topic

Covers designing a news/feed system (fanout on write vs read, ranking, pagination) and stream processing: event streams, Kafka, and processing data in real time. You’ll build a feed and see how Instagram-style systems work.

• Chapter 12: Design a Chat System (Alex Xu)
• Chapter 12: The Future of Data Systems (DDIA)
• Video: WhatsApp System Design
• Project: Build a real-time chat app with WebSockets (Node.js + Socket.io)
• Blog: Primary or alternative topic

Covers designing a chat/messaging system (1:1, groups, presence, delivery, scale) and the future of data systems: unbundled databases, ML/AI workloads, and ethical use. You’ll build a real-time chat app and tie the curriculum to modern AI engineering.