System Design Interview Learning Path

A structured 10-week preparation path for system design interviews. This is the most comprehensive path in the Knowledge Vault, covering 12 fundamentals pages, 12 patterns pages, 10 interview mastery pages, estimation practice, the zero-to-million-users progression, 48 interview walkthroughs, and easy/medium/hard practice question sets.

Who This Is For

• Engineers preparing for system design interviews at FAANG and top-tier companies
• Mid-level engineers aiming for senior roles that require design rounds
• Anyone who wants a structured approach to learning system design (not just memorizing solutions)

Prerequisites

• 1+ years of backend engineering experience
• Basic understanding of databases, APIs, and web architecture
• Familiarity with at least one programming language
• No prior system design interview experience required

Total estimated time: ~60 hours across 10 weeks

Learning Progression

---

Week 1-2: System Design Fundamentals

Estimated reading time: 6 hours

Build the mental model that every system design answer starts from. These 12 pages cover the building blocks you will reference in every interview.

• [ ] Required -- How the Internet Works (25 min)
• [ ] Required -- Client-Server Architecture (20 min)
• [ ] Required -- System Design Glossary (20 min)
• [ ] Required -- System Characteristics (25 min)
• [ ] Required -- Building Blocks (30 min)
• [ ] Required -- Scaling Fundamentals (30 min)
• [ ] Required -- Redundancy & Replication (25 min)
• [ ] Required -- SQL vs NoSQL (25 min)
• [ ] Required -- Proxies (20 min)
• [ ] Required -- How to Read Architecture Diagrams (20 min)
• [ ] Required -- Estimation Practice (30 min)
• [ ] Required -- Zero to Million Users (35 min)

Interview Tip

The "zero to million users" page is your secret weapon. It shows how a system evolves from a single server to a distributed architecture. Interviewers love candidates who start simple and scale incrementally.

---

Week 2-3: Databases & Storage

Estimated reading time: 5 hours

Every system design involves data storage. Know when to use what, how databases scale, and the key internal mechanisms.

• [ ] Required -- Database Selection Guide (20 min)
• [ ] Required -- Storage Engines (30 min)
• [ ] Required -- Indexing Deep Dive (25 min)
• [ ] Required -- Replication (30 min)
• [ ] Required -- Sharding (30 min)
• [ ] Required -- PostgreSQL Internals (30 min)
• [ ] Required -- Multi-Region Database (25 min)
• [ ] Optional -- Redis Internals (25 min)
• [ ] Optional -- Elasticsearch Internals (25 min)
• [ ] Optional -- Cassandra Internals (25 min)
• [ ] Optional -- DynamoDB Internals (20 min)
• [ ] Optional -- ClickHouse Internals (20 min)
• [ ] Optional -- Time-Series Databases (15 min)

Interview Tip

When discussing databases, always mention: read/write ratio, data model (relational vs document vs key-value), consistency requirements, and expected data volume. These drive the choice.

---

Week 3-4: Caching & Message Queues

Estimated reading time: 4.5 hours

Caching

• [ ] Required -- Caching Strategies (25 min)
• [ ] Required -- Cache Invalidation (25 min)
• [ ] Required -- Redis Caching Patterns (25 min)
• [ ] Required -- Multi-Layer Caching (20 min)
• [ ] Required -- CDN Deep Dive (25 min)
• [ ] Optional -- Cache Sizing Math (20 min)
• [ ] Optional -- Thundering Herd (15 min)
• [ ] Optional -- Cache Warming (15 min)

Message Queues

• [ ] Required -- Message Queues Overview (15 min)
• [ ] Required -- Queue Selection Guide (20 min)
• [ ] Required -- Kafka Internals (30 min)
• [ ] Required -- Ordering Guarantees (20 min)
• [ ] Required -- Exactly-Once Semantics (25 min)
• [ ] Required -- Dead Letter Queues (15 min)
• [ ] Optional -- RabbitMQ Internals (20 min)
• [ ] Optional -- Backpressure Patterns (20 min)

Interview Tip

When you add a cache or queue, always address: failure modes ("what happens when the cache goes down?"), consistency guarantees, and capacity planning. These show depth.

---

Week 4-5: Networking & Load Balancing

Estimated reading time: 4 hours

Networking

• [ ] Required -- DNS Deep Dive (25 min)
• [ ] Required -- HTTP/2 & HTTP/3 (25 min)
• [ ] Required -- gRPC Internals (20 min)
• [ ] Required -- WebSockets (20 min)
• [ ] Required -- WebRTC (20 min)
• [ ] Optional -- TLS Handshake (15 min)
• [ ] Optional -- TCP/IP Deep Dive (25 min)
• [ ] Optional -- QUIC Protocol (20 min)

Load Balancing

• [ ] Required -- Load Balancing Overview (10 min)
• [ ] Required -- L4 vs L7 (20 min)
• [ ] Required -- Algorithms (25 min)
• [ ] Required -- Health Checks (15 min)
• [ ] Optional -- Session Affinity (15 min)
• [ ] Optional -- Global Load Balancing (20 min)

Interview Tip

Explain load balancing at DNS, L4, and L7 levels. This shows you understand the full network stack.

---

Week 5-6: System Design Patterns

Estimated reading time: 6 hours

These 12 pattern pages are the vocabulary of system design. Master them and you can construct any architecture.

• [ ] Required -- Scalability Patterns (25 min)
• [ ] Required -- Availability Patterns (25 min)
• [ ] Required -- Consistency Patterns (25 min)
• [ ] Required -- Communication Patterns (25 min)
• [ ] Required -- Data Partitioning (25 min)
• [ ] Required -- ID Generation (20 min)
• [ ] Required -- Search Patterns (25 min)
• [ ] Required -- Notification Patterns (20 min)
• [ ] Required -- Event vs Request (20 min)
• [ ] Required -- Microservices vs Monolith (20 min)
• [ ] Optional -- Blob Storage (20 min)
• [ ] Optional -- Distributed Logging (20 min)

Architecture patterns:

• [ ] Required -- Microservices Overview (15 min)
• [ ] Required -- API Gateway Pattern (20 min)
• [ ] Required -- Event-Driven Architecture (15 min)
• [ ] Optional -- Eventual Consistency (20 min)
• [ ] Optional -- Transactional Outbox (20 min)

Interview Tip

Do not default to microservices for every design. Start simple and explain when/why you would evolve. This shows maturity.

---

Week 6-7: Distributed Systems Deep Dive

Estimated reading time: 5 hours

Every system design interview involves distributed systems. You must be fluent in CAP, consistency, consensus, and failure modes.

• [ ] Required -- Distributed Systems Overview (15 min)
• [ ] Required -- CAP Theorem (25 min)
• [ ] Required -- Consistency Models (30 min)
• [ ] Required -- Consistent Hashing (25 min)
• [ ] Required -- Distributed Transactions (30 min)
• [ ] Required -- Distributed Locking (25 min)
• [ ] Required -- Circuit Breaker (20 min)
• [ ] Required -- Rate Limiting (25 min)
• [ ] Required -- Bloom Filters (20 min)
• [ ] Optional -- Gossip Protocols (20 min)
• [ ] Optional -- CRDT Fundamentals (25 min)
• [ ] Optional -- Vector Clocks & Lamport Timestamps (25 min)
• [ ] Optional -- Failure Detectors (20 min)

Consensus protocols (know at least Raft):

• [ ] Required -- Consensus Overview (10 min)
• [ ] Required -- Raft Full Walkthrough (30 min)
• [ ] Optional -- Paxos Made Simple (25 min)
• [ ] Optional -- Leader Election (20 min)

Interview Tip

When asked about consistency, do not just say "CAP theorem." Discuss the spectrum from linearizable to eventual consistency and explain the trade-offs for the specific system.

---

Week 7: Interview Mastery

Estimated reading time: 5 hours

These 10 pages teach you the meta-skill of how to ace the interview itself.

• [ ] Required -- Interview Framework (30 min)
• [ ] Required -- Estimation Cheat Sheet (25 min)
• [ ] Required -- Common Mistakes (20 min)
• [ ] Required -- Discussing Tradeoffs (25 min)
• [ ] Required -- Deep Dive Topics (25 min)
• [ ] Required -- Templates (25 min)
• [ ] Required -- Mock Walkthrough (30 min)

Estimation practice:

• [ ] Required -- Estimation Practice (30 min -- revisit)

Practice questions by difficulty:

• [ ] Required -- Easy Practice Questions (25 min)
• [ ] Required -- Medium Practice Questions (25 min)
• [ ] Required -- Hard Practice Questions (25 min)

Back-of-the-Envelope Numbers

Memorize these for quick estimation:

Resource	Value
QPS a single web server handles	1,000-10,000
QPS a single database handles	1,000-5,000
Redis operations/second	100,000+
Kafka throughput	1M+ messages/second
1 KB per record, 1M records	~1 GB
1 KB per record, 1B records	~1 TB
Read latency: memory	~100 ns
Read latency: SSD	~100 us
Read latency: HDD	~10 ms
Round trip same datacenter	~0.5 ms
Round trip cross-continent	~150 ms

Interview Tip

Practice the mock walkthrough page end to end. It simulates the 35-minute interview format so you get comfortable with pacing.

---

Week 8: Easy Interview Walkthroughs

Estimated reading time: 6 hours

Start with simpler systems. Focus on applying the framework cleanly.

• [ ] Required -- Design a URL Shortener (30 min)
• [ ] Required -- Design a Rate Limiter (30 min)
• [ ] Required -- Design a Key-Value Store (30 min)
• [ ] Required -- Design a Parking Lot (25 min)
• [ ] Required -- Design a Leaderboard (25 min)
• [ ] Required -- Design a Notification System (30 min)
• [ ] Required -- Design Search Autocomplete (30 min)
• [ ] Required -- Design a Typeahead (25 min)
• [ ] Required -- Design a Distributed Cache (30 min)

Real-world reference blueprints:

• [ ] Optional -- Rate Limiter Blueprint (15 min)
• [ ] Optional -- Rate Limiter Algorithms (25 min)
• [ ] Optional -- Notification Service Architecture (25 min)

---

Week 9: Medium Interview Walkthroughs

Estimated reading time: 8 hours

These require deeper trade-off analysis and more components.

• [ ] Required -- Design WhatsApp / Chat System (35 min)
• [ ] Required -- Design Twitter / News Feed (35 min)
• [ ] Required -- Design Twitter Search (30 min)
• [ ] Required -- Design Instagram (35 min)
• [ ] Required -- Design E-Commerce (35 min)
• [ ] Required -- Design a Payment System (35 min)
• [ ] Required -- Design an Email Service (30 min)
• [ ] Required -- Design a Web Crawler (30 min)
• [ ] Required -- Design Dropbox (30 min)
• [ ] Required -- Design a CDN (30 min)
• [ ] Required -- Design an API Gateway (30 min)
• [ ] Required -- Design Reddit (30 min)
• [ ] Required -- Design a Hotel Booking System (30 min)
• [ ] Required -- Design a News Aggregator (25 min)

Real-world reference blueprints:

• [ ] Optional -- Auth Service Architecture (25 min)
• [ ] Optional -- Billing Engine Architecture (25 min)
• [ ] Optional -- Job Queue Architecture (25 min)
• [ ] Optional -- Chat Service Blueprint (25 min)

---

Week 10: Hard Interview Walkthroughs

Estimated reading time: 8 hours

These are the most complex designs. They test distributed systems depth and architectural maturity.

• [ ] Required -- Design YouTube (35 min)
• [ ] Required -- Design Netflix (35 min)
• [ ] Required -- Design Uber (35 min)
• [ ] Required -- Design Spotify (35 min)
• [ ] Required -- Design Google Docs (35 min)
• [ ] Required -- Design Google Maps (35 min)
• [ ] Required -- Design Slack (30 min)
• [ ] Required -- Design Zoom (30 min)
• [ ] Required -- Design LinkedIn (30 min)
• [ ] Required -- Design Airbnb (35 min)
• [ ] Required -- Design a Stock Exchange (35 min)
• [ ] Required -- Design a Ticket Booking System (30 min)
• [ ] Required -- Design a Social Network (30 min)
• [ ] Required -- Design a Recommendation Engine (30 min)
• [ ] Required -- Design a Search Engine (35 min)
• [ ] Required -- Design Search Ranking (30 min)
• [ ] Required -- Design a Fraud Detection System (30 min)
• [ ] Required -- Design a Live Streaming Platform (30 min)
• [ ] Required -- Design Tinder (30 min)
• [ ] Required -- Design a Food Delivery System (30 min)
• [ ] Required -- Design an Ad Platform (30 min)
• [ ] Required -- Design a Content Moderation System (30 min)
• [ ] Required -- Design ChatGPT (35 min)
• [ ] Required -- Design GitHub Copilot (30 min)
• [ ] Required -- Design GitHub (30 min)

Company architecture references:

• [ ] Optional -- Discord Scaling (25 min)
• [ ] Optional -- Uber Dispatch (25 min)
• [ ] Optional -- Figma Multiplayer (25 min)
• [ ] Optional -- Shopify Black Friday (25 min)

---

What You Will Be Able to Do After This Path

• Apply a structured 4-step framework to any system design question
• Perform back-of-the-envelope estimations in under 3 minutes
• Choose the right database, cache, queue, and communication pattern for a given workload
• Design systems at multiple scale levels (single server to global)
• Discuss trade-offs fluently (consistency vs availability, latency vs throughput, cost vs reliability)
• Walk through 48 complete system design interview questions confidently
• Identify and avoid common interview mistakes
• Handle deep-dive questions on distributed systems, consensus, and failure modes

Cross-References to Related Paths

• Backend Engineer Path -- Fill gaps in databases, DDD, CQRS, and Spring Boot
• DevOps Engineer Path -- Understand deployment, SRE, and infrastructure
• Data Engineer Path -- Learn data pipeline design for analytics questions
• Platform Engineer Path -- Understand the infrastructure layer
• Security Engineer Path -- Add security considerations to your designs

---

Total Progress

This path contains approximately 120 pages including 48 interview walkthroughs. For interview prep, aim to complete weeks 1-7 first (the fundamentals), then work through walkthroughs by difficulty level. Practice at least 2-3 designs per week aloud with a timer.