Skip to main content

Explore Problems

Certifications Pricing Discuss

Fundamentals of System Design

Course Contents

What Is System Design? (And Why It Runs the World)

The Trade-off Mindset: There Are No Right Answers

From One User to One Million: How a System Grows

System Design in 30 Concepts: The Aerial View

How This Course Works + Your Study Plan

Diagnostic: Where Should You Start?

One System, Five Passes: Meet Your Capstone

Checkpoint: Welcome & How to Think

Anatomy of a Server: One Request, Start to Finish

The Memory Hierarchy: Disk, RAM, CPU Cache

Sequential vs Random Access: Why Order Matters

Processes vs Threads: Units of Work

The 10K Connections Problem

Connection Pools: Reuse Beats Re-open

Concurrency vs Parallelism

Shared State & Race Conditions: Why Locks Exist

The Four Bottlenecks: CPU, Memory, Disk, Network

Checkpoint: Computer & OS Foundations

Scalability: Vertical vs Horizontal

Stateful vs Stateless: Where Does State Live?

Availability & the Nines

Reliability & Fault Tolerance: Failing Without Falling

Single Point of Failure — and Redundancy, the Antidote

Latency vs Throughput vs Bandwidth

Performance vs Scalability

Consistency: First Taste of the Hardest Trade-off

Maintainability, Simplicity & Cost

Checkpoint: Core Concepts & Non-Functional Requirements

IP & Addressing (OSI, the Useful Parts)

DNS: The Internet's Phonebook

HTTP/1.1 to HTTP/2 to HTTP/3 (QUIC)

TLS: Security's Latency Bill

Proxies: Forward vs Reverse

Anycast: One IP, Many Places

Checksums: Trust but Verify

Checkpoint: Networking

Load Balancers: The Traffic Directors

Load Balancing Algorithms

L4 vs L7 Load Balancing (+ Sticky Sessions)

Health Checks & Failover

Global Load Balancing: GeoDNS & Anycast

Rate Limiting: Token Bucket, Leaky Bucket, Windows

Codelab: Load-Balance Two Servers with nginx

Checkpoint: Load Balancing & Traffic

API Design & REST: Contracts Between Strangers

Pagination, Filtering & Sorting

Idempotency: Safe to Retry

Data Formats & Serialization: JSON, Protobuf, Avro

Schema Evolution & API Versioning

GraphQL: Ask for Exactly What You Need

gRPC & Streaming

API Gateways: The Front Door

AuthN vs AuthZ: Sessions & JWT

Checkpoint: APIs

Polling & Long-Polling

WebSockets: The Two-Way Street

Server-Sent Events

Webhooks: We'll Call You

WebRTC in 15 Minutes (+ How Zoom Scales)

Sync vs Async: The Decoupling Decision

Calling Services Safely: Timeouts, Retries & Backoff

Message Queues: Absorbing the Burst

Queue Models: Broker (RabbitMQ) vs Log (Kafka)

Pub/Sub: Broadcasting Events

Delivery Semantics: At-Most, At-Least, Exactly-Once

Codelab: Produce & Consume with Kafka

Checkpoint: Real-time & Async Communication

Why Caching Wins

Caching Patterns: Aside, Read-Through, Write-Through, Write-Behind

Cache Eviction: LRU, LFU, TTL, FIFO

Cache Invalidation: The Second-Hardest Problem

Stampedes, Thundering Herds & Cache Warming

Distributed Caching (+ Consistent-Hashing Intuition)

CDNs: Caching at the Edge

CDN Invalidation & Edge Strategies

Codelab: Cache a Slow Endpoint with Redis

Checkpoint: Caching

How Engineers Measure Systems

Back-of-the-Envelope: Estimate Like an Engineer

Numbers to Know

Estimation Walkthroughs: QPS, Storage, Bandwidth

Estimation Practice

From Numbers to Architecture

Checkpoint: Estimation & Numbers

Capstone Pass 1: The Marketplace MVP

Sequential vs Random Access: Why Order Matters

Sequential vs Random Access: Why Order Matters on CodePeet.

Loading...

Loading content...