System Design · Free course · Phase 1 + 2 + 3

System Design Course: Scaling, Estimation, and Interview-Ready Designs

Twenty-two lessons with diagrams — from "one server is melting" through rate limiters, URL shorteners, distributed primitives, web crawlers, notifications, news feeds, and chat. Pair each chapter with Schoolabe labs and mock interviews.

22 lessons · ~13 hours

Start with Lesson 1: When One Server Isn't Enough

Learning path

1

Foundations

Lesson 1: When One Server Isn't Enough

CPU, memory, disk, and network limits on one server. Vertical vs horizontal scaling and load balancing when good traffic becomes too much.

2

Foundations

Lesson 2: Scaling the Data Layer

Read replicas, sharding intro, Redis cache-aside, CDN, and a five-stage diagram that ties the scaling story together.

3

Foundations

Lesson 3: Do the Math on a Napkin

Powers of 2, latency anchors, QPS and storage math, plus a worked social-feed estimate for interviews.

4

Foundations

Lesson 4: What Interviewers Want in 45 Minutes

Four steps interviewers expect, a 45-minute timeline, and a checklist so you do not draw boxes too early.

5

Design

Lesson 5: Token Bucket vs Sliding Window

Fixed window, sliding window, token bucket, leaky bucket — trade-offs and what to say in the room.

6

Design

Lesson 6: Building a Distributed Rate Limiter

Redis-backed distributed rate limiting, atomic counters, gateway placement, fail open vs closed.

7

Design

Lesson 7: How Short Links Actually Work

Shorten and redirect flows, base62 IDs, collisions, and API design from scratch.

8

Design

Lesson 8: Scaling Short Links to Millions

Cache hot links, CDN redirects, schema, capacity math, and what skeptical interviewers ask next.

9

Phase 2

Lesson 9: When Hash Modulo Breaks

Why hash % N breaks when you add servers, and how the hash ring minimizes key movement.

10

Phase 2

Lesson 10: Virtual Nodes and CDN Routing

Virtual nodes, uneven load fixes, and consistent hashing in Redis clusters and CDN routing.

11

Phase 2

Lesson 11: The Simplest Database Interviewers Love

GET/PUT/DELETE design, in-memory vs disk, and LSM vs B-tree storage engines on one node.

12

Phase 2

Lesson 12: Replicating and Sharding a KV Store

Replication, quorum reads/writes, sharding with consistent hashing, and CAP trade-offs.

13

Phase 2

Lesson 13: Counting Without Collisions

Auto-increment limits, UUID trade-offs, collision math, and sortable vs random IDs.

14

Phase 2

Lesson 14: Snowflake IDs at Scale

Snowflake bit layout, clock skew, datacenter IDs, and ULID alternatives at scale.

15

Phase 3

Lesson 15: How Web Crawlers Actually Work

URL frontier, fetcher, parser, dedup, and robots.txt — how search engines discover pages.

16

Phase 3

Lesson 16: Crawling Billions of Pages

Distributed workers, shared frontiers, Bloom filters, and politeness at billion-page scale.

17

Phase 3

Lesson 17: When Your App Needs to Ping Users

Event queues, delivery workers, and push/SMS/email channels with templates and idempotency.

18

Phase 3

Lesson 18: Ten Million Push Notifications

Fan-out to millions, worker pools, retries, dead-letter queues, and provider rate limits.

19

Phase 3

Lesson 19: Why Your Feed Feels Instant

Follow graph, fan-out on write vs read, timeline APIs, and the celebrity problem.

20

Phase 3

Lesson 20: Scaling Feeds Past the Celebrity Problem

Hybrid fan-out, Redis timelines, ranking pipelines, and caching for hot users.

21

Phase 3

Lesson 21: How WhatsApp-Style Chat Works

WebSockets, message storage, 1:1 and group chat, and sent/delivered/read states.

22

Phase 3

Lesson 22: A Hundred Million Messages a Day

Conversation sharding, gateway scaling, presence in Redis, and offline message sync.

Foundations (Lessons 1–4)

Scaling, data layers, napkin math, and how to run a 45-minute interview.

Design problems — Phase 1 (Lessons 5–8)

Rate limiter and URL shortener — split into algorithms and architecture.

Distributed building blocks — Phase 2 (Lessons 9–14)

Consistent hashing, key-value stores, and distributed ID generation — the primitives behind bigger designs.

Design problems — Phase 3 (Lessons 15–22)

Web crawler, notifications, news feed, and chat — each split into core design and at-scale architecture.

Practice labs & challenges

All Labs Hub

Interactive scaling, sharding, and consistency labs

Scaling Lab

Simulate adding servers under load

Request Flow Lab

Trace requests through layers

Sharding Lab

Partition data across shards

Consistency Lab

Explore CAP trade-offs

Design Challenges

Timed architecture scenarios

Mock Interview

System design interview practice

Frequently asked questions

Is this system design course free?

Yes. All Phase 1, Phase 2, and Phase 3 lessons, diagrams, and linked labs are free on Schoolabe. No paywall on the course content.

How long does the course take?

Phase 1 is about 4–5 hours. Phase 2 adds another 3–4 hours. Phase 3 adds about 4–5 hours more. Add time for interactive labs under /system-design/labs and mock interview practice.

Do I need backend experience first?

Basic familiarity with APIs, databases, and HTTP helps. If you have finished our Node.js or Python web chapters, you are ready. Absolute beginners should skim scaling basics twice — the ideas stack quickly.

Does this replace reading a system design book?

This is a structured, interview-focused path with Schoolabe labs and mock interviews. Books go deeper on some topics. Use this course as your guided path; explore books and papers for extra depth.

What comes after Phase 2?

Phase 3 covers web crawlers, notification systems, news feeds, and chat — four full interview designs split into core and at-scale lessons. More design problems roll out as the curriculum grows.

Is Phase 3 included for free?

Yes. Phase 3 lessons (15–22) are free like the rest of the course — diagrams, reading, and linked labs where applicable.

Related Courses

Apache Kafka

Master Apache Kafka for real-time data streaming. Learn event-driven architecture, producers, consumers, and distributed systems.

Node.js Development

Server-side JavaScript development, APIs, databases, and deployment. Build robust backend systems.

Master Your Logic Building

Build strong programming logic before starting DSA. Master conditionals, loops, recursion, arrays, strings, and mixed challenges through 6 progressive phases.