System Design Crash Course

Lesson 1 • Estimating Scale and Capacity

Teaches back-of-the-envelope maths to size systems before designing them. Accurate estimates prevent over-engineering and under-provisioning.

Lesson 2 • Core Distributed Systems Concepts

Introduces latency, throughput, availability, and consistency as the four pillars of distributed reasoning. These concepts underpin every trade-off discussed later.

Lesson 3 • Defining System Requirements

Covers structured requirement gathering using clarifying questions and constraint mapping. Produces a clear problem statement that guides all subsequent design decisions.

Lesson 1 • Real-Time Communication Techniques

Explores WebSockets and streaming protocols for low-latency, bidirectional data flows. Prepares students to design chat, gaming, and live-feed systems.

Lesson 2 • How the Internet Works

Covers DNS resolution, TCP/IP, and HTTP as the backbone of web communication. Provides the networking context needed to reason about latency and reliability.

Lesson 3 • Synchronous vs. Asynchronous Communication

Distinguishes request-response from event-driven patterns and their impact on coupling. Asynchronous design is foundational to scalable, resilient architectures.

Lesson 1 • NoSQL Database Categories

Surveys key-value, document, column-family, and graph stores with their ideal use cases. Matching data model to store type is the central skill of this section.

Lesson 2 • Database Scaling Strategies

Covers replication, sharding, and read replicas as the primary tools for scaling storage. Each strategy introduces specific consistency and operational trade-offs.

Lesson 3 • Relational Database Fundamentals

Reviews ACID properties, normalisation, and indexing as the core of relational storage. These concepts are prerequisites for understanding when to move beyond SQL.

Lesson 1 • Cache Invalidation Strategies

Addresses write-through, write-behind, and cache-aside patterns as the three core invalidation approaches. Incorrect invalidation is the leading cause of stale data bugs.

Lesson 2 • Caching Fundamentals

Defines cache hits, misses, eviction policies, and TTL as the vocabulary of caching. Understanding these mechanics is required before applying any caching pattern.

Lesson 3 • Advanced Caching Challenges

Covers thundering herd, cache stampede, and hotspot problems that emerge at scale. Solving these requires probabilistic techniques and careful key design.

Lesson 1 • Vertical vs. Horizontal Scaling

Contrasts scaling up a single machine with scaling out across many nodes. Horizontal scaling is the foundation of modern cloud-native architecture.

Lesson 2 • Auto-Scaling and Elasticity

Covers reactive and predictive auto-scaling policies tied to metrics and schedules. Proper scaling policies prevent both over-provisioning and traffic-induced outages.

Lesson 3 • Global Traffic Distribution

Introduces GeoDNS, anycast routing, and multi-region active-active deployments. Global distribution reduces latency for international users and improves disaster resilience.

Lesson 1 • Event Streaming Platforms

Covers log-based streaming as a durable, replayable alternative to traditional queues. Streaming enables real-time analytics, event sourcing, and audit trails.

Lesson 2 • Event-Driven Architecture Patterns

Applies event sourcing, CQRS, and saga patterns to complex distributed workflows. These patterns solve consistency problems that two-phase commit cannot handle at scale.

Lesson 3 • Delivery Guarantees and Ordering

Distinguishes at-most-once, at-least-once, and exactly-once delivery semantics. Ordering guarantees affect correctness in financial, inventory, and audit systems.

Lesson 1 • Chaos Engineering and SLO Management

Applies controlled failure injection to validate resilience assumptions before production incidents occur. SLOs translate reliability goals into measurable, actionable targets.

Lesson 2 • Failure Modes in Distributed Systems

Catalogs network partitions, node crashes, and Byzantine faults as the primary failure classes. Recognising failure modes is the prerequisite for designing against them.

Lesson 3 • Circuit Breakers and Bulkheads

Introduces circuit breakers and bulkhead isolation as the two primary fault-containment patterns. These prevent a single failing dependency from collapsing the entire system.

Lesson 1 • Designing a URL Shortener

Applies the framework to a classic, well-scoped problem covering hashing, redirection, and analytics. Demonstrates how simple requirements reveal deep storage and caching decisions.

Lesson 2 • Designing a Distributed Rate Limiter

Builds a token bucket and sliding window rate limiter that works across multiple nodes. Demonstrates how distributed state management complicates seemingly simple algorithms.

Lesson 3 • Designing a Notification System

Covers multi-channel delivery, priority queuing, and deduplication for push, email, and SMS. Integrates messaging, storage, and reliability patterns from all prior chapters.

Lesson 4 • Designing a Social Media Feed

Tackles fan-out on write vs. fan-out on read for news feed generation at scale. Exposes the tension between write amplification and read latency in high-follower scenarios.