System Design Course

Lesson 1 • Requirements Gathering and Scoping

Covers techniques for extracting and prioritising requirements before designing. Connects clear scoping to better architectural decisions.

Lesson 2 • Back-of-Envelope Estimation

Teaches rapid quantitative estimation of load, storage, and bandwidth. Grounds design decisions in realistic numbers from the start.

Lesson 3 • What Is System Design

Defines system design as the process of defining architecture, components, and data flow. Establishes vocabulary used throughout the course.

Lesson 1 • Synchronous vs. Asynchronous Communication

Contrasts request-response with event-driven messaging patterns. Connects communication style to latency and coupling trade-offs.

Lesson 2 • Internet and Protocol Fundamentals

Reviews TCP/IP, DNS, and HTTP as the backbone of distributed communication. Provides context for higher-level design choices.

Lesson 3 • API Design Patterns

Compares REST, GraphQL, and RPC as primary API paradigms. Guides selection based on client needs and system constraints.

Lesson 1 • NoSQL Database Categories

Surveys key-value, document, column-family, and graph stores. Maps each category to appropriate use cases.

Lesson 2 • Storage Engine Selection

Provides a decision framework for choosing between relational, NoSQL, and specialised stores. Reinforces trade-off reasoning from earlier sections.

Lesson 3 • Relational Database Fundamentals

Covers ACID properties, normalisation, and indexing in relational databases. Anchors later comparisons with NoSQL alternatives.

Lesson 4 • CAP Theorem and Consistency Models

Explains the CAP theorem and its practical implications for distributed storage. Introduces consistency spectrum from eventual to strong.

Lesson 1 • Cache Consistency Patterns

Examines cache-aside, write-through, write-behind, and read-through patterns. Connects each pattern to consistency and performance trade-offs.

Lesson 2 • Caching Layers and Placement

Covers client-side, CDN, application, and database caches. Shows how layer placement affects latency and consistency.

Lesson 3 • Caching Fundamentals

Defines cache hits, misses, eviction policies, and TTL. Establishes the performance impact of caching in distributed systems.

Lesson 1 • Vertical vs. Horizontal Scaling

Contrasts scaling up hardware with scaling out instances. Establishes when each approach is appropriate and its cost implications.

Lesson 2 • Auto-Scaling and Elasticity

Teaches reactive and predictive auto-scaling based on metrics. Prepares students to design cost-efficient elastic architectures.

Lesson 3 • Rate Limiting and Throttling

Introduces token bucket, leaky bucket, and sliding window algorithms. Protects system resources from overload and abuse.

Lesson 4 • Load Balancing Strategies

Covers round-robin, least-connections, and consistent-hash algorithms. Connects algorithm choice to traffic patterns and session requirements.

Lesson 1 • Disaster Recovery and Backup

Covers RTO, RPO, backup strategies, and multi-region failover. Prepares students to design systems that survive catastrophic failures.

Lesson 2 • Replication and Consensus

Explains leader-follower replication and consensus algorithms for agreement. Connects replication strategy to consistency and availability goals.

Lesson 3 • Idempotency and Exactly-Once Semantics

Addresses duplicate requests and message delivery guarantees. Ensures correctness in the presence of retries and network failures.

Lesson 4 • Fault Tolerance Patterns

Teaches circuit breakers, retries, timeouts, and bulkheads. Equips students to prevent cascading failures in distributed services.

Lesson 1 • Service Discovery and Registration

Explains client-side and server-side discovery patterns for dynamic service location. Enables resilient routing in elastic environments.

Lesson 2 • Service Decomposition Principles

Applies domain-driven design and bounded contexts to define service boundaries. Reduces coupling whilst maximising cohesion.

Lesson 3 • Distributed Data Management

Addresses the saga pattern, two-phase commit, and eventual consistency across services. Solves distributed transaction challenges.

Lesson 4 • Inter-Service Communication

Covers synchronous REST/gRPC and asynchronous event-driven communication between services. Connects choice to latency and coupling trade-offs.

Lesson 1 • Designing a Real-Time Chat System

Builds a chat architecture using WebSockets, message queues, and presence detection. Synthesises networking, storage, and scalability chapters.

Lesson 2 • Designing a URL Shortener

Walks through a complete URL shortener design covering hashing, storage, and redirection. Reinforces estimation, caching, and database selection.

Lesson 3 • Design Interview Framework

Provides a structured approach to scoping, estimating, and presenting system designs. Builds confidence and consistency in design sessions.

Lesson 4 • Designing a Distributed File Storage

Designs a large-scale file storage system with chunking, metadata, and replication. Applies distributed systems concepts to blob storage.

Lesson 5 • Designing a Social Feed System

Covers fan-out-on-write vs. fan-out-on-read for news feed generation. Integrates caching, ranking, and notification subsystems.