New intermediate

System Design Course: HLD Fundamentals and Case Studies

Free system design course: estimation, caching, sharding, CAP, queues and APIs, plus URL shortener, rate limiter, chat, news feed and notification designs.

Lessons
15
Modules
5
Time
10-12 hours

Your progress

0 of 15 lessons done 0%
Start with Lesson 1
  • Free, no sign-up
  • Progress saved in this browser
  • Code you can copy and run

What you'll learn

  • Run any design problem through a 5-step framework, from requirements to deep dives
  • Estimate QPS, storage and server counts in minutes
  • Scale stateless tiers with load balancers, CDNs and autoscaling
  • Choose caching patterns and avoid stampedes, hot keys and stale data
  • Pick databases, indexes, replication and shard keys with confidence
  • Explain CAP, PACELC, consistency levels and quorums (R + W > N)
  • Use queues, idempotency and good API design to decouple services
  • Design a URL shortener, rate limiter, chat system, news feed and notification system

Course curriculum

15 lessons in 5 modules · 10-12 hours

Module 1

Foundations

3 lessons
  1. Lesson 1: How to Approach a System Design Problem A repeatable 5-step framework for system design interviews and real projects: requirements, estimates, API, high-level design, then deep dives. 30-40 min beginner
  2. Lesson 2: Back-of-the-Envelope Estimation Estimate QPS, storage, bandwidth and server counts in minutes. Powers of two, latency numbers and a worked URL shortener example in Python. 30-40 min beginner
  3. Lesson 3: Scaling and Load Balancing Vertical vs horizontal scaling, stateless services, L4 vs L7 load balancers, balancing algorithms, health checks, sessions, CDNs and autoscaling. 35-45 min beginner

Module 2

Data and Storage

4 lessons
  1. Lesson 4: Caching Strategies and Pitfalls Cache-aside, read-through, write-through and write-back caching, TTLs and eviction, invalidation, plus stampedes and hot keys, with runnable Python. 40-50 min intermediate
  2. Lesson 5: Databases, Indexes and Replication Choose SQL or NoSQL, understand indexes and their cost, and scale reads with leader-follower replication: sync vs async, lag and failover. 40-50 min intermediate
  3. Lesson 6: Sharding and Consistent Hashing Split data across machines with range, hash and directory sharding, pick a shard key, avoid hot spots, and rebalance cheaply with consistent hashing. 40-50 min intermediate
  4. Lesson 7: CAP Theorem, Consistency and Quorums The CAP theorem explained properly, PACELC, strong vs eventual consistency, and quorum reads and writes (R + W > N) with a Python simulation. 35-45 min intermediate

Module 3

Communication

2 lessons
  1. Lesson 8: Message Queues and Async Processing Decouple services with message queues and event streams: queue vs log, delivery guarantees, idempotent consumers, retries, dead letters and backpressure. 35-45 min intermediate
  2. Lesson 9: API Design: REST, gRPC and WebSockets Design clean APIs for large systems: REST resources, gRPC, WebSockets and SSE, pagination, idempotency keys, versioning and API gateways. 35-45 min intermediate

Module 4

Case Studies

5 lessons
  1. Lesson 10: Design a URL Shortener (TinyURL) URL shortener system design step by step: requirements, estimates, base62 codes, ID generation, database and cache choices, redirects and analytics. 50-60 min intermediate
  2. Lesson 11: Design a Rate Limiter Rate limiter system design: token bucket, leaky bucket, fixed and sliding windows with Python code, then a distributed limiter on Redis at scale. 45-55 min intermediate
  3. Lesson 12: Design a Chat System (WhatsApp) Chat system design like WhatsApp: WebSocket gateways, message routing, ordering, storage, delivery receipts, presence, group chats and offline push. 50-60 min advanced
  4. Lesson 13: Design a News Feed (Twitter/Instagram) News feed system design: fan-out on write vs fan-out on read, the hybrid for celebrities, feed caches, ranking, pagination and media, with Python. 45-55 min advanced
  5. Lesson 14: Design a Notification System Notification system design for push, SMS and email: event intake, user preferences, templating, per-channel queues, retries, dedup and rate limits. 40-50 min intermediate

Module 5

Production

1 lesson
  1. Lesson 15: Reliability, Monitoring and a Checklist Make designs survive failure: redundancy, timeouts, retries, circuit breakers, SLOs, monitoring and disaster recovery, plus a design interview checklist. 35-45 min intermediate