What you will learn
- What “high-level design” (HLD) means and how it differs from low-level design.
- A five-step framework you can apply to any design question.
- How to turn a vague prompt into functional and non-functional requirements.
- The most common ways candidates (and teams) go wrong.
What system design is
System design is deciding which components a product needs (servers, databases, caches, queues, CDNs), how they talk, and how the whole thing behaves as traffic grows and parts fail. It’s called high-level design because you work with boxes and arrows, not classes and methods. Class-level design is the subject of our Low-Level Design course.
There’s rarely one right answer. A good design is one whose trade-offs are explicit and fit the requirements: cheaper vs faster, simpler vs more available, fresher data vs lower latency.
The five-step framework
1. Requirements what must it do, and how well? (5-8 min)
2. Estimates how big is it? (3-5 min)
3. API + data model what goes in and out, what is stored? (5 min)
4. High-level design boxes and arrows for the main flows (10-15 min)
5. Deep dives bottlenecks, failures, trade-offs (10-15 min)
The times are for a 45-minute interview; in a real design document the same steps take days. The order matters more than the timing.
Step 1: Requirements
Split them in two.
Functional requirements are features: “users can shorten a URL”, “a short URL redirects to the original”, “links can expire”. Pick the 2–4 that matter most and say what you’re leaving out.
Non-functional requirements are qualities, ideally with numbers:
| Quality | Question to ask | Example answer |
|---|---|---|
| Scale | How many users / requests? | 100M new links a day |
| Latency | How fast must it feel? | Redirect p99 under 50 ms |
| Availability | How much downtime is OK? | 99.99% for redirects |
| Consistency | Can readers see stale data? | A new link may take a second to work everywhere |
| Durability | Can we ever lose data? | Never lose a created link |
Non-functional requirements drive the architecture. “Read-heavy with strict latency” points to caching; “must never lose a payment” points to strong consistency and replication with synchronous acknowledgement.
Step 2: Estimates
Rough numbers decide whether one database is enough or you need fifty shards. Lesson 2 teaches the arithmetic.
Step 3: API and data model
Write the few endpoints the core flows need and the main entities:
POST /links {long_url, expires_at?} -> {code}
GET /{code} -> 301/302 redirect
links(code PK, long_url, owner_id, created_at, expires_at)
This keeps the rest of the discussion concrete.
Step 4: High-level design
Draw the request path for each core flow. Start simple, then add components only when a requirement demands them:
client -> load balancer -> app servers -> database
|
+-> cache (because reads are 100x writes)
Step 5: Deep dives
Pick the hardest parts and go deep: the hot key, the database that won’t fit on one machine, what happens when a data centre fails. Name the bottleneck, offer two options, choose one and say why.
Common mistakes
- Designing before asking. Five minutes of questions saves twenty of redesign.
- Buzzword architecture. Adding Kafka, Kubernetes and five microservices to a system with 100 users. Every component must earn its place.
- No numbers. “It needs to scale” means nothing; “350k reads per second at peak” means a cache.
- Ignoring failure. Every box can die. What happens then?
- Silence about trade-offs. Saying “I chose X over Y because…” is the core skill being tested.
How this course is organised
Lessons 2–9 build the toolbox: estimation, scaling, caching, databases, sharding, consistency, queues and APIs. Lessons 10–14 apply it to classic case studies: a URL shortener, a rate limiter, a chat system, a news feed and a notification system. Lesson 15 covers reliability and a printable checklist. For practice prompts, pair this course with the HLD practice sheet.
Key takeaways
- High-level design is about components, data flow and trade-offs, not code.
- Follow the order: requirements, estimates, API/data model, high-level design, deep dives.
- Non-functional requirements (scale, latency, availability, consistency) drive the architecture.
- Add components only when a requirement justifies them, and always state the trade-off.
Exercises
- For “design Instagram”, write three functional and four non-functional requirements with numbers you’d propose.
- Take a system you use at work or university and draw its high-level diagram in under ten boxes.
- Pick any prompt from the HLD sheet and spend 10 minutes only on step 1. List the questions you’d ask the interviewer.
Quiz
- What is the difference between a functional and a non-functional requirement?
- Why should estimates come before drawing the architecture?
- Name two signs of “buzzword architecture”.
Show answers
- Functional requirements describe what the system does (features); non-functional ones describe how well it must do it (scale, latency, availability, consistency, durability).
- The numbers decide which components you need: whether one database suffices, whether you need a cache, sharding or a CDN.
- Components added without a requirement that needs them, and complexity (many services, queues, clusters) far beyond the stated scale.