System Design Mastery Path¶
System design is the craft of deciding how a piece of software should be split across machines, where its data lives, how requests move through it, and what happens when parts of it fail. It is also a standard interview round for mid-level and senior engineering roles. This course treats those as the same skill: if you can reason clearly about a real system, you can explain that reasoning in 45 minutes on a whiteboard.
The lessons avoid "draw these five boxes" recipes. Every design choice has a cost, and the course keeps asking the same questions: what does this buy us, what does it cost, what breaks first, and how would we know? You will estimate load with arithmetic before choosing components, pick consistency levels deliberately rather than by habit, and learn which famous-sounding guarantees (exactly-once delivery, "CA" systems, infinitely scalable databases) are marketing more than engineering.
Each lesson includes a How It Actually Works section that opens up the mechanism underneath the buzzword: how a load balancer picks a backend, how a replica catches up from a write-ahead log, why consistent hashing moves only a fraction of keys, how Raft elects a leader, what a token bucket actually stores. Where code helps, it is short, runnable Python you can execute locally with no cloud account. Diagrams are drawn inline so you can see the request path.
About the numbers
Back-of-envelope figures on this site (latencies, throughput per server, storage costs) are rough rules of thumb for reasoning at the order-of-magnitude level. Real numbers depend on hardware, configuration, and workload — always measure your own system before committing to a design based on them.
How the program is organized¶
| Level | Focus | Modules |
|---|---|---|
| Level 1 · Entry | Approach, HTTP, estimation, scaling, load balancing, caching, databases, CDNs, API styles | 9 topics + 1 project (URL shortener) |
| Level 2 · Intermediate | Replication, sharding, consistent hashing, CAP/PACELC, queues, rate limiting, indexing, invalidation, object storage | 9 topics + 1 project (news feed) |
| Level 3 · Advanced | Consensus, sagas, idempotency, event-driven design & CDC, search, real-time, observability, reliability, hot keys | 9 topics + 1 project (chat system) |
| Level 4 · Master | Case studies (streaming, dispatch, file storage, payments), multi-region, cost, security, interview framework, design docs | 9 topics + 1 capstone (your own design doc) |
How to use this site¶
- Read Levels 1 and 2 in order; later lessons lean on vocabulary from earlier ones. Level 3 is where distributed-systems reasoning gets serious. Level 4 applies everything to full systems.
- Attempt each project before reading the walkthrough. Give yourself 45 minutes, a sheet of paper, and a timer. Then compare — the gaps are what you study next.
- Run the Python snippets. Watching a consistent-hash ring rebalance or a token bucket refill teaches more than reading about it.
- Do the Exercise at the end of every lesson. Most are small design problems with no single right answer; write down your trade-offs explicitly.
- If you are preparing for interviews, pair this with the DSA & Coding Interviews Mastery Path for the coding rounds.
Start here → Level 1 · Entry
🎥 Prefer video? Watch the Mastery Path video series on YouTube — Shorts and full walkthroughs of lessons across the series.
More from the Mastery Path series¶
Free, structured, module-wise training across 66 other languages, platforms and disciplines:
Languages
Web Frameworks
Testing & QA
Security
Cloud Platforms
Data & Analytics
AI / ML / LLM
Embedded Systems
Leadership & Management
Professional Skills
Careers & Interviews
Process & APIs
Infrastructure & Ops