Backend System Design
Backend System Design Overview
What interviewers evaluate, how a 45–60 minute round is structured, and the framework you should follow every time.
1. Interview structure
Backend system design interviews evaluate whether you can design systems that are scalable, reliable, and maintainable — and explain trade-offs clearly under time pressure.
- Requirements gathering — functional and non-functional requirements
- High-level architecture — components and how they interact
- Deep dives — schema, scaling, caching, failure modes
- Operational concerns — monitoring, failure handling, deployment
2. Interview framework (45–60 minutes)
2.1 Clarify requirements (~5 minutes)
Functional requirements
- Core features (what must work on day one)
- Target users and primary workflows
- Inputs and outputs of the system
Non-functional requirements
- Scale: users, requests per second, data volume
- Latency targets (p50 / p99)
- Consistency vs availability trade-offs
- Read vs write ratio
Ask clarifying questions out loud. Do not invent scale silently.
2.2 Back-of-envelope estimation (~3–5 minutes)
Compute enough numbers to justify later choices:
- Requests per second (average and peak)
- Storage over 1–5 years
- Bandwidth needs
See Estimation for the full method and reference tables.
2.3 High-level design (~10–15 minutes)
Name the main components and draw data flow:
Start with the simplest design that meets requirements. Add pieces only when scale or reliability demands them.
2.4 Deep dive (~15–20 minutes)
Pick 2–3 areas and go deep:
- Database schema and indexing
- API design (REST / RPC, idempotency)
- Caching strategy and invalidation
- Failure handling and scaling bottlenecks
2.5 Wrap up (~5 minutes)
- Summarize the design in 4–5 sentences
- Call out monitoring and alerting
- Mention future improvements (multi-region, stronger consistency, etc.)
3. Key trade-offs (always be ready)
| Trade-off | Option A | Option B |
|---|---|---|
| SQL vs NoSQL | ACID, complex queries | Horizontal scale, flexible schema |
| Consistency vs Availability | Money, inventory | Feeds, analytics |
| Push vs Pull | Real-time UX | Huge fan-out |
| Cache vs Database | Read-heavy latency | Write-heavy consistency |
| Sync vs Async | Simple, immediate feedback | Decoupling, reliability |
4. Preparation guidelines
- Practice verbal explanation — this is a discussion, not a monologue.
- Draw diagrams — visual communication matters.
- Memorize reference numbers — latency, throughput, storage.
- Study production systems — Netflix, Uber, Airbnb eng blogs.
- Start simple, then scale — never jump to Kafka on minute two.
5. Common interview questions
Practice full designs after you know the framework. Grouped the same way as the System Design hub:
Data Systems
Real-Time Systems
Content and Social
Infrastructure
More practice: YouTube, Google Drive, Payment System, Booking System, and others on the hub.
Quick revision
- Order: Clarify → estimate → HLD → deep dive → wrap-up.
- NFRs: RPS, latency, consistency, read/write ratio.
- Start simple: one app + DB; add cache/LB/queue when needed.
- Trade-offs: say why you chose SQL/NoSQL, sync/async, push/pull.
- Ops: metrics, alerts, failover — mention at the end.