System Design
Start with requests and responses, build up through caches, queues and databases, then design real systems like a URL shortener and a notification service.
Lessons in order
- 01Beginner 11 min
Client and Server
What actually happens when you open a website: who asks, who answers, and why the split exists at all.
- 02Beginner 12 min
Request and Response
What a request and a response actually contain, why statelessness matters, and how headers shape almost everything.
- 03Beginner 12 min
HTTP and HTTPS
What HTTPS actually adds, how the certificate handshake works in plain terms, and what it does not protect you from.
- 04Beginner 13 min
DNS — Turning Names Into Addresses
How a domain name becomes an IP address, what each record type does, and why DNS changes seem to take hours.
- 05Beginner 11 min
Domain Names
How domains are structured and rented, what a registrar actually does, and the practical decisions around subdomains and email.
- 06Beginner 12 min
IP Addresses and Ports
How machines are addressed, what a port really is, and why private addresses and NAT exist.
- 07Beginner 13 min
Load Balancer
How one address can be served by many machines, what health checks do, and why sticky sessions cause trouble.
- 08Beginner 12 min
Reverse Proxy
What a reverse proxy does, why your application should not face the internet directly, and the jobs it takes off your hands.
- 09Beginner 12 min
CDN — Serving From Nearby
Why distance costs milliseconds, how edge caching removes most of your traffic, and how to avoid serving stale content.
- 10Intermediate 14 min
Cache — Remembering Expensive Answers
Store expensive results so you compute them once. Learn where caches live, common strategies, and why invalidation is genuinely hard.
- 11Beginner 13 min
Database — Where the Truth Lives
Why applications need a database rather than files, what transactions guarantee, and why connection pooling matters.
- 12Intermediate 13 min
SQL vs NoSQL
What each family is genuinely good at, the questions that decide between them, and why "NoSQL scales better" is too simple.
- 13Intermediate 14 min
Database Indexes
How an index turns a full table scan into a jump, what they cost, and how to tell which ones you actually need.
- 14Intermediate 13 min
Replication — Copies of Your Data
Keep copies of your database on other machines for reads, failover and safety — and understand the lag that comes with it.
- 15Advanced 14 min
Sharding — Splitting the Data
When one database cannot hold the writes, split the data across several. Learn shard keys, the costs, and why it is a last resort.
- 16Intermediate 14 min
Message Queues
Hand slow work to a queue so requests stay fast, absorb traffic spikes, and survive failures without losing tasks.
- 17Intermediate 13 min
Background Workers
The processes that consume queues and run scheduled work: how to size them, keep them healthy, and shut them down safely.
- 18Intermediate 13 min
WebSockets — Two-Way Connections
When the server needs to push data to the client, and what changes in your architecture when connections stay open.
- 19Intermediate 13 min
Object Storage
Store uploads and generated files in a service built for it, with presigned URLs, lifecycle rules and a CDN in front.
- 20Intermediate 15 min
Authentication — Proving Who You Are
How a system knows who is making a request: password storage done properly, sessions versus tokens, and the trade-offs of each.
- 21Intermediate 14 min
Authorization — What You May Do
Once you know who someone is, decide what they may do. Roles, permissions, ownership checks and the mistakes that leak data.
- 22Intermediate 14 min
Rate Limiting
Protect your system from abuse and accidental overload by capping how often a client can call you, and doing it fairly.
- 23Beginner 13 min
Logging
Write logs you can search during an incident: levels, structure, correlation IDs, and what must never appear in them.
- 24Intermediate 14 min
Monitoring
Know that something is wrong before users tell you: the four signals worth measuring, percentiles over averages, and alerting without fatigue.
- 25Intermediate 13 min
Horizontal Scaling
Handle more load by running more machines. What your application must give up to make that possible, and where the new bottleneck appears.
- 26Beginner 11 min
Vertical Scaling
Adding CPU, memory or faster disks to one machine is often the cheapest fix. Learn when it wins and where it stops.
- 27Intermediate 13 min
High Availability
Keep a system serving traffic when parts of it fail: removing single points of failure, failover, and what the nines actually cost.
- 28Intermediate 14 min
Fault Tolerance
Assume every dependency will fail and design for it: timeouts, bounded retries, circuit breakers, bulkheads and fallbacks.
- 29Beginner 12 min
Monolith
One deployable application containing everything. Its genuine advantages, its real limits, and why most projects should start here.
- 30Intermediate 13 min
Modular Monolith
Keep one deployment but enforce internal boundaries, so the codebase stays workable and services can be extracted later if needed.
- 31Advanced 15 min
Microservices
Independent services with their own data and deployments: the real benefits, the considerable costs, and when the trade is worth making.
- 32Advanced 14 min
Event-Driven Architecture
Components announce facts instead of calling each other, which decouples them — and makes the flow harder to follow.
- 33Intermediate 15 min
REST API Design
Design an API other people can use without asking you questions: resource naming, correct status codes, pagination, errors and versioning.
- 34Intermediate 12 min
API Gateway
A single entry point that routes, authenticates, rate limits and shapes traffic for everything behind it.
- 35Intermediate 16 min
Design a URL Shortener
A complete walkthrough: requirements, key generation, storage choice, caching, redirects and analytics for a link shortener.
- 36Advanced 16 min
Design a Chat Application
Message delivery, persistent connections across many servers, ordering, read receipts and history for a chat system.
- 37Advanced 16 min
Design a Social Media Feed
Build a timeline: fan-out on write versus on read, the celebrity problem, ranking, and how the hybrid approach works.
- 38Intermediate 15 min
Design a File Upload System
Handle uploads at scale: presigned direct uploads, resumable transfers, virus scanning, processing pipelines and safe serving.
- 39Intermediate 16 min
Design a Notification System
Send email, SMS and push reliably: templates, preferences, deduplication, rate limits, retries and delivery tracking.
- 40Advanced 17 min
Design an E-commerce System
The full path from browsing to payment: catalogue search, inventory reservation, checkout, idempotent payments and order state.
- 41Intermediate 15 min
Design a Job Portal
Two-sided marketplace design: job search with faceted filters, application tracking, recommendations and keeping the index fresh.
- 42Advanced 15 min
Design an API Rate Limiter
Build a rate limiter that works across many servers: algorithm choice, shared counters, atomicity, and what to do when the limiter itself fails.