Course Roadmap

Before you dive in, it helps to see the full map. Here's everything this course covers, how it's organized, and how to navigate it based on where you're starting from.

How the Course Is Structured

The course is divided into chapters, each focusing on a distinct area of system design. They're sequenced intentionally, each chapter builds on the vocabulary and concepts introduced before it. That said, if you're experienced and have gaps in specific areas, feel free to jump around.

Chapter 1 — Welcome

Get oriented with the course layout and roadmap.

• Course Introduction — How to use this course effectively
• Course Roadmap — You are here

Chapter 2 — Introduction to System Design

Establish the fundamentals and core terminology of system design.

• What is System Design? — The high-level view and design process
• 30 Must-Know Concepts — A reference glossary you'll keep coming back to

Chapter 3 — Core Concepts

Learn the foundational metrics and theorems behind distributed systems.

• Scalability — Horizontal vs vertical scaling concepts
• Availability — Designing for high uptime (SLAs, SLOs)
• Reliability — Ensuring system correctness under stress
• Single Point of Failure (SPOF) — Identifying and eliminating weak links
• Latency vs Throughput vs Bandwidth — Measuring system performance
• Consistent Hashing — Key distribution in dynamic environments
• CAP Theorem — Balancing consistency, availability, and partition tolerance
• Consistency Models — Strict, eventual, sequential, and causal consistency

Chapter 4 — Networking

Understand the network layer and protocol stack that carries your system's data.

• OSI Model — The 7-layer stack demystified
• IP Address — IPv4/IPv6, subnetting, and routing basics
• TCP vs UDP — Choosing transport layer protocols
• HTTP/HTTPS — Evolution from HTTP/1.1 to HTTP/3 and transport security
• Domain Name System (DNS) — The internet's phonebook
• Checksums — Verifying data integrity
• Proxy vs Reverse Proxy — Edge routing and security boundaries

Chapter 5 — Load Balancing

Learn how to distribute traffic across your infrastructure efficiently.

• What are Load Balancers? — The traffic cops of distributed systems
• Load Balancing Algorithms — Round robin, least connections, IP hash, and more
• DNS Load Balancing — Distributing traffic at the DNS level
• Anycast Routing — Routing traffic to the nearest topological location

Chapter 6 — API Fundamentals

Design robust, clean, and secure application programming interfaces.

• What is an API? — Interface design basics
• Idempotency — Ensuring safe retries in APIs
• Data Formats — JSON, XML, Protocol Buffers, and FlatBuffers
• API Architectural Styles — REST, GraphQL, gRPC, and SOAP
• REST API Design — Best practices for resource-based APIs
• GraphQL Deep Dive — Querying nested and relational data
• gRPC Deep Dive — High-performance RPC using HTTP/2
• API Gateways — Routing, rate limiting, and request shaping
• Rate Limiting — Protecting systems from abuse and traffic spikes
• Authentication vs Authorization — Verifying identity vs verifying permissions
• Session vs Token Based Auth — Session IDs vs JWTs
• JWT — Structure, validation, and security of JSON Web Tokens
• OAuth / OAuth2 — Delegation protocols for third-party access
• Single Sign-On (SSO) — Unified login systems

Chapter 7 — Communication Patterns

Explore how services talk to each other in real-time or asynchronously.

• Long Polling — Simulated real-time using persistent HTTP connections
• WebSockets — Full-duplex bidirectional communication
• Server-Sent Events (SSE) — One-way server push
• Webhooks — Event-driven HTTP callbacks
• WebRTC — Peer-to-peer real-time media and data
• Sync vs Async Communication — Request-response vs event-driven
• Message Queues — Point-to-point asynchronous messaging
• Pub/Sub — One-to-many event distribution
• Change Data Capture (CDC) — Streaming database changes
• Delivery Semantics — At-least-once, at-most-once, and exactly-once delivery
• Dead Letter Queues — Handling unprocessable messages

Chapter 8 — Caching

Boost performance and reduce database load using caching strategies.

• What is Caching? — High-level patterns and benefits
• Cache-Aside Pattern — Lazy loading data on demand
• Read-Through vs Write-Through — Keeping caches and stores in sync
• Write-Behind Cache — Asynchronous writes for extreme write throughput
• Caching Strategies Summary — A comparison matrix of caching patterns
• Cache Eviction Policies — LRU, LFU, FIFO, and random eviction
• Content Delivery Network (CDN) — Edge caching for static and dynamic assets
• Distributed Cache Architecture — Sharding cache data across nodes
• Cache Invalidation — The hardest problem in programming
• Cache Stampede — Mitigating simultaneous cache miss storms
• Cache Warming — Prepopulating caches prior to traffic spikes

Chapter 9 — Databases

Understand storage options, ACID guarantees, and database internals.

• Database Types — From relational to vector and graph databases
• SQL vs NoSQL — The primary trade-offs and design philosophies
• ACID Transactions — Atomicity, Consistency, Isolation, and Durability
• Relational Databases — Tables, schemas, and relational keys
• Document Databases — Semi-structured, schema-less document storage
• Key-Value Stores — High-speed simple dictionary storage
• Wide Column Databases — Columns families and sparse storage
• Graph Databases — Node-and-edge relationships for highly connected data
• Time Series Databases — Optimizing for telemetry, logs, and metrics
• Full-Text Search Engines — Inverted indexes for text querying
• Vector Databases — Similarity searches for AI and embeddings
• B-Trees and B+ Trees — Read-optimized indexing data structures
• LSM Trees — Write-optimized indexing data structures
• How Databases Guarantee Durability — Write-ahead logs (WAL) and fsync

Chapter 10 — Database Scaling Techniques

Scale your storage tier beyond a single node or optimize database performance.

• Indexing — Creating efficient search paths on data
• Vertical Partitioning — Splitting tables by column
• Query Optimization — Analyzing query plans and optimizing indexes
• Read Replicas — Scaling read throughput via replication
• Denormalization — Trading write complexity for read performance
• Materialized Views — Precomputing complex queries
• Connection Pooling — Reusing database connections
• Sharding — Horizontally partitioning data across nodes
• Sharding vs Partitioning — The key differences in terminology
• Data Compression — Reducing storage footprint and disk I/O

Chapter 11 — Storage Systems

Store and manage large unstructured files and binary data.

• Block vs File vs Object Storage — Choosing the right storage interface
• Object Storage — Flat namespaces for large unstructured blobs (e.g., S3)
• Distributed File Systems — Hierarchical storage across multiple nodes
• Erasure Coding — High-efficiency data durability and parity

Chapter 12 — Tradeoffs

Master the core design choices that shape distributed architectures.

• Vertical vs Horizontal Scaling — Scale up vs scale out
• Concurrency vs Parallelism — Managing multiple tasks vs running them simultaneously
• Push vs Pull Architecture — Choosing data flow direction
• Stateful vs Stateless Architecture — Designing for server-side state or scalability
• Long Polling vs WebSockets — Choosing the right real-time protocol
• Strong vs Eventual Consistency — Sacrificing latency for correctness or vice-versa

Chapter 13 — Distributed System Fundamentals

Deep dive into the theory and mechanics of distributed systems.

• Challenges of Distribution — Network reliability, latency, and partial failures
• Network Partitions — Dealing with network splits and connection drops
• Split Brain Problem — Mitigating split authority in active clusters
• Heartbeats — Monitoring node health and network connectivity
• Handling Failures in Distributed Systems — Fault detection and failover
• Clock Synchronization Problem — The physical limits of synchronizing time
• Logical Clocks — Ordering events without physical clocks
• Lamport Timestamps — Determining causal order
• Vector Clocks — Detecting concurrent writes and conflicts
• Consensus Algorithms — The search for agreement in distributed nodes
• Paxos Algorithm — The foundational consensus protocol
• Raft Algorithm — Replicated state machines made understandable
• Leader Election — Electing coordinator nodes in a cluster
• Distributed Locks — Safe mutual exclusion across nodes
• Gossip Protocol — Decentralized information dissemination
• CRDTs — Conflict-free Replicated Data Types
• Operational Transformation — Collaborative real-time editing mechanics

Chapter 14 — Distributed Transactions

Coordinate transactions across independent database systems.

• The Problem with Distributed Transactions — Why distributed transactions are slow and fragile
• Two-Phase Commit (2PC) — Blocking consensus for atomic transactions
• Three-Phase Commit (3PC) — Non-blocking transactional consensus
• SAGA Pattern — Event-driven local transactions with compensations
• Outbox Pattern — Reliably publishing events from databases

Chapter 15 — Data Structures for Scale

Discover data structures designed specifically to operate under high volumes of data.

• Introduction — Scaling data structures
• Geohash — Spatial indexing using string representations
• Quad Trees — Hierarchical spatial decomposition
• R-Trees — Indexing multidimensional bounding boxes
• S2 and H3 — Global grid indexing systems from Google and Uber
• Bloom Filters — Space-efficient probabilistic membership testing
• Cuckoo Filter — Dynamic deletion support for probabilistic testing
• HyperLogLog — Probabilistic cardinality estimation for massive datasets
• Count-Min Sketch — Frequency estimation for stream processing
• MinHash — Jaccard similarity estimation for document comparison
• Skip Lists — Probabilistic alternative to balanced search trees
• Merkle Trees — Cryptographic tree hashes for data synchronization

Chapter 16 — Architectural Patterns

Learn the high-level templates for structuring enterprise applications.

• Client-Server Architecture — Classic separation of concerns
• Monolithic Architecture — Single deployable unit structures
• Microservices Architecture — Decentralized, domain-driven services
• Serverless Architecture — On-demand cloud execution models
• Event-Driven Architecture — Asynchronous reactive systems
• Peer-to-Peer (P2P) — Decentralized, node-to-node collaboration
• Hexagonal Architecture — Separating business logic from external dependencies
• CQRS — Command Query Responsibility Segregation
• Event Sourcing — Reconstructing state from an append-only event log

Chapter 17 — Microservices Patterns

Solve coordination and structural challenges in a microservices deployment.

• Service Discovery — Dynamically locating service endpoints
• API Gateway Pattern — Consolidating entry points for microservices
• Backend for Frontend (BFF) — Custom backends for specific client apps
• Sidecar Pattern — Co-locating auxiliary application features
• Circuit Breaker Pattern — Preventing failure propagation to downstream dependencies
• Bulkhead Pattern — Isolating resources to prevent complete outages
• Strangler Fig Pattern — Migrating from monolith to microservices incrementally
• Service Mesh — Infrastructure layer for service-to-service communication

Chapter 18 — Big Data Processing

Process, transform, and analyze massive volumes of data.

• Batch vs Stream Processing — Periodic vs continuous data computation
• MapReduce — Distributed processing of large data sets
• ETL Pipelines — Extracting, transforming, and loading data
• Data Lakes — Storing raw, unstructured data at scale
• Data Warehousing — Structured analytical database storage
• Data Lakehouse — Combining the features of data lakes and warehouses
• Lambda Architecture — Combining batch and speed layers for querying
• Kappa Architecture — Stream-only processing architectures
• Streaming Engines — Apache Flink, Spark Streaming, and Storm comparison

Chapter 19 — Deployment Patterns

Deploy software updates safely, with zero downtime and fast rollbacks.

• Deployment Strategies Overview — Comparing deployment mechanisms
• CI/CD Pipelines — Continuous Integration and Continuous Deployment automation
• Rolling Deployments — Phased updates across server nodes
• Blue-Green Deployments — Instant switching between environment versions
• Canary Releases — Routing a fraction of traffic to new versions
• Feature Flags — Decoupling deployments from code releases
• A/B Testing Infrastructure — Comparing features in production
• Schema Migrations — Safe database schema updates without downtime
• Rollbacks & Immutable Infrastructure — Returning to previous known states

Chapter 20 — Observability

Understand what's happening inside your systems at any moment.

• Three Pillars of Observability — Logs, Metrics, and Traces
• Logging Best Practices — Designing structured, parsable logs
• Log Aggregation — Centralizing logs from distributed nodes
• Correlation IDs — Tracking requests across service boundaries
• Metrics & Instrumentation — Collecting CPU, memory, latency, and custom metrics
• Alert & Monitoring — Designing action-oriented alerts
• Dashboards & Runbooks — Visualizing metrics and documenting incident responses
• Distributed Tracing — Tracking request lifecycles through call stacks

Chapter 21 — Advanced Security

Secure data and control access in distributed production systems.

• SSL/TLS — Encrypting communication in transit
• Encryption at Rest — Securing data stored on disk
• Secrets Management — Storing API keys, credentials, and certificates securely
• Password Management — Salting and hashing credentials
• RBAC — Role-Based Access Control mechanics
• SAML — Security Assertion Markup Language for identity federation

---

Recommended Learning Paths

Path A — Complete Beginner

You're a developer who hasn't thought much about distributed systems or scale.

Don't rush. Read each chapter twice if you need to. The concepts in Chapters 3-8 are the foundation for everything else.

Path B — Mid-Level Engineer

You understand the basics, have worked with databases and APIs, and want to level up for senior roles.

Pay extra attention to the trade-off discussions in each section — that's what interviewers probe at the senior level.

Path C — Interview Fast-Track

You have an interview in 2-3 weeks and need to cover the most ground quickly.

Use the concept lists to stress-test your understanding under simulated interview conditions.

---

How Each Lesson Is Built

Every lesson in this course follows the same structure so you always know where you are:

1. The concept — plain English explanation, no assumed knowledge
2. How it works — internals, diagrams, the machinery underneath
3. Trade-offs — the honest "it depends" discussion
4. Real-world context — how actual companies use this
5. Summary — key takeaways before you move on

---

Summary

The course covers 21 chapters, from welcoming foundations to advanced security concepts. Whether you're brand new to distributed systems or filling in specific gaps, there's a path through this material that works for you. Start where you are, go deep where it matters, and use the chapters to put the pieces together.