Free course · Technology
System Design From Zero to Interview-Ready
A free, 45-article course that takes you from basic web and backend ideas to designing and defending real systems in SDE-1 and SDE-2 interviews. It teaches a repeatable method (requirements, estimation, APIs, data, baseline, scaling, hardening), the building blocks and distributed-systems fundamentals behind it, and 15 progressively harder case studies.
- 45
- lessons
- 12
- modules
- 12 h
- of reading
Curriculum
12 modules · 45 lessons · about 12 h
Module 1System Design Foundations3 lessons · 54 min
Module 2APIs and Communication2 lessons · 36 min
Module 3Capacity Estimation2 lessons · 31 min
Module 4Core Building Blocks4 lessons · 1 h 13 min
- 08Load Balancers: How They Work, Algorithms, Health Checks and Stateless Services18 min
- 09Caching in System Design: Patterns, Invalidation, Eviction and Redis20 min
- 10CDNs and Object Storage: Serving Files, Images and Video at Scale17 min
- 11Message Queues, Pub/Sub and Event Streams: How Asynchronous Systems Work18 min
Module 5Databases6 lessons · 1 h 35 min
- 12Relational Databases and Data Modeling for System Design17 min
- 13Database Indexes and Query Performance: How to Make Reads Fast15 min
- 14Transactions, Isolation Levels and Concurrency Control: Preventing Race Conditions16 min
- 15Database Replication: Primary-Replica, Read Replicas, Lag and Failover15 min
- 16Database Sharding and Partitioning: How It Works and When You Need It17 min
- 17SQL vs NoSQL: Data Models and How to Choose the Right Database15 min
Module 6Distributed Systems5 lessons · 1 h 18 min
- 18Why Distributed Systems Are Hard: Partial Failure, Timeouts and Clocks14 min
- 19CAP Theorem and Consistency Models Explained Without the Myths15 min
- 20Idempotency, Retries and Message Delivery Guarantees17 min
- 21Distributed Transactions: Two-Phase Commit, the Outbox Pattern and Sagas16 min
- 22Distributed Locks, Leases, Leader Election and Consensus16 min
Module 7Reliability and Operations3 lessons · 44 min
Module 8Architecture and Security3 lessons · 44 min
Module 9Interview Method and Foundation Case Studies4 lessons · 1 h 8 min
Module 10Real-World Case Studies7 lessons · 1 h 57 min
- 33Design a Notification System: Email, SMS and Push at Scale17 min
- 34Design a Chat System Like a Messaging App18 min
- 35Design a News Feed: Fan-Out, Ranking and the Celebrity Problem16 min
- 36Design Search Autocomplete (Typeahead)14 min
- 37Design a Distributed Job Scheduler17 min
- 38Design a Ticket Booking System Without Overselling16 min
- 39Design a Payment System: Idempotency, Ledgers and Reconciliation19 min
Module 11Large-Scale Case Studies5 lessons · 1 h 23 min
- 40Design a Video Streaming Platform: Upload, Transcoding and Adaptive Streaming15 min
- 41Design a Ride-Hailing System: Location, Matching and Real-Time Updates18 min
- 42Design a Food Delivery Platform: Orders, Restaurants and Delivery Partners17 min
- 43Design an E-Commerce System: Catalog, Cart, Checkout, Inventory and Flash Sales16 min
- 44Design a Web Search Engine: Crawling, Inverted Indexes and Ranking17 min
Module 12Interview Readiness1 lesson · 14 min
This is a free course on high-level system design, written for people who are starting with little or no system-design knowledge and want to reach the point where they can approach, explain and defend a design in an SDE-1 or SDE-2 interview. It teaches reasoning, not diagrams to memorise: every component is introduced from the problem it solves, every design starts simple and grows only where something breaks, and every design is asked what happens when its parts fail.
Who it is for
- Complete beginners to system design.
- Students and early-career developers preparing for software interviews.
- SDE-1 candidates who need clear fundamentals.
- Developers moving from implementing features to designing systems.
- SDE-2 candidates and backend developers who need stronger distributed-systems depth.
How the course is organised
Read in order. Each article builds on the ones before it, and each says what to read first. Capacity estimation comes before the building blocks on purpose: you need numbers to know whether a component is necessary. Databases come before distributed-systems theory, and all of the theory comes before the case studies that use it.
Module | Articles | What it builds |
|---|---|---|
1. System Design Foundations | Start Here, Requirements and Quality Attributes, How a Web Request Travels | The method, requirements as numbers, and the path of a request |
2. APIs and Communication | Clean, retry-safe APIs, and when to wait, defer or push | |
3. Capacity Estimation | Back-of-the-Envelope Estimation, Storage, Bandwidth, Cache and Servers | From users to QPS, bytes, Gbps, memory and machines |
4. Core Building Blocks | Load Balancers, Caching, CDNs and Object Storage, Message Queues and Streams | The components in almost every design, and why each exists |
5. Databases | Relational Databases and Data Modeling, Indexes, Transactions and Concurrency, Replication, Sharding, SQL vs NoSQL | The data layer in depth |
6. Distributed Systems | Why Distributed Systems Are Hard, CAP and Consistency, Idempotency and Retries, Distributed Transactions, Locks and Leader Election | Correctness when many machines share work and data |
7. Reliability and Operations | Fault Tolerance, High Availability and Disaster Recovery, Observability | Staying up, recovering, and seeing inside the system |
8. Architecture and Security | Monolith vs Microservices, Event-Driven Architecture, Security | Structuring and securing a whole system |
9. Interview Method and Foundation Case Studies | Interview Framework, URL Shortener and Pastebin, Rate Limiter, Distributed Cache | The repeatable interview method, applied three times |
10. Real-World Case Studies | Notification System, Chat System, News Feed, Search Autocomplete, Job Scheduler, Ticket Booking, Payment System | Designs that combine several blocks and add correctness concerns |
11. Large-Scale Case Studies | Video Streaming, Ride-Hailing, Food Delivery, E-Commerce, Web Search | Multi-service data flows, partitioning and pipelines at scale |
12. Interview Readiness | A plan, a self-scoring rubric, extra problems and a checklist |
Levels: from foundation to SDE-2
Level | Articles | Focus |
|---|---|---|
Foundation | 01 to 07 | Vocabulary, requirements, requests, APIs, communication styles, estimation |
SDE-1 core | 08 to 13, 29 to 32 | Building blocks, relational data and indexes, three foundation case studies |
Intermediate | 14 to 17, 33 to 36 | Transactions, replication, sharding, database choice, combined designs |
SDE-2 | 18 to 28, 37 to 44 | Distributed systems, reliability, architecture, security, large-scale designs |
Short on time and aiming for SDE-1? Read 01 to 13, then 15, 17, 20, 29, 30, 31 and 33, then 45. Aiming for SDE-2? Read everything, and spend extra time on Module 6, Module 7 and the Level 2 and 3 case studies.
The method used in every design
Every article practises the same seven phases, and every case study follows them:
- Clarify functional and non-functional requirements, and agree what is out of scope.
- Estimate traffic, storage, bandwidth and cache size with stated assumptions.
- Interface: define the main APIs, including idempotency where it matters.
- Data: model entities, keys and indexes around access patterns.
- Baseline: draw the simplest architecture that works and walk a request through it.
- Scale: ask what breaks first, fix that, and repeat.
- Harden: failures, reliability, consistency, security, observability, trade-offs, then a two-minute summary.
Article 29 turns this into a 21-item interview checklist and a time plan for a 45-minute round.
Case-study progression
The 15 case studies get harder in three steps. Level 1 (URL shortener and Pastebin, rate limiter, distributed cache) teaches the method on systems built around one or two components. Level 2 (notifications, chat, news feed, autocomplete, job scheduler, ticket booking, payments) combines several components and adds correctness problems such as duplicates, overselling and money. Level 3 (video streaming, ride-hailing, food delivery, e-commerce, web search) adds multi-service data flows, partitioning and asynchronous pipelines. Every case study uses the same 14 headings, so you can compare them and practise the structure until it is automatic.
About the code and the cloud examples
- System design is language-agnostic. Java (21) is used for a handful of small, deterministic programs that model ideas such as pagination, LRU caching, consistent hashing, rate limiting and retries. Each complete program starts with a
// File:comment and is followed by its real output. Short fragments without that comment, including Spring-style snippets, are illustrations. If you use another language, read the Java as pseudocode. - Cloud services are examples, not prerequisites. Each concept is taught first, then mapped to common implementations (for example "object storage, such as Amazon S3, Google Cloud Storage or Azure Blob Storage"). You should be able to design every system here without any particular provider. Product names are current as of October 2026 and change over time.
- Numbers. Scale figures in examples are labelled assumptions or are computed in the text. Figures about real products (such as a storage service's designed durability) are quoted from official documentation and listed in each article's sources.
How to study
Read once for the idea. Redraw every diagram from memory. Redo every estimate yourself. Explain each design out loud as if to an interviewer. Attempt each exercise for 15 to 20 minutes before opening its solution. Revise after a day, a week and a month. From Module 9 onwards, attempt each case study on paper, with a 45-minute timer, before reading it. Article 45 gives an eight-week plan and a self-scoring rubric.
Must-know and nice-to-know
As a rough guide for interviews:
- Must-know for everyone: requirements, estimation, API design, load balancing and stateless services, caching, CDNs and object storage, queues, relational modelling and indexes, replication basics, SQL versus NoSQL trade-offs, idempotency, and the interview method.
- Expected at SDE-2: transactions and isolation, sharding and hot partitions, consistency models and CAP, delivery semantics, sagas and the outbox pattern, fault tolerance and overload handling, disaster recovery, observability with SLOs, architecture styles, and security design.
- Good depth, asked less often: consensus details, event sourcing, multi-region active-active writes, and the internals of search engines.
Articles mark optional depth when they reach it.