A system design interview asks you to design something like a URL shortener or chat app in about 45 minutes, and it judges your reasoning, not one correct answer. Clarify requirements, estimate load, sketch the API and data model, draw the high-level design, deep-dive one bottleneck and state trade-offs. Free resources cover all of it.
This page is for students and developers in India preparing for system design rounds. Every resource link was opened on 11 November 2026, and the free-versus-paid table records what a visitor without an account could read that day. Numbers in the code are practice assumptions, not measurements. The three Python blocks were run on Python 3.9, and their output matches the numbers quoted.
The 45-minute split is our own synthesis, close to the delivery framework of Hello Interview and the steps in the System Design Primer, both cited below. No company publishes its rubric, so the notes on what interviewers want are our reading, not survey data.
- 1Requirementsscope, scale, 5 min
- 2Estimatesload and storage, 4 min
- 3APIendpoints, 5 min
- 4Data modelentities and keys, 5 min
- 5High-level designboxes and flow, 10 min
- 6Deep diveone bottleneck, 10 min
- 7Trade-offsfailures and wrap-up, 4 min
What the interview tests, and a 45-minute framework
Hello Interview describes the round as taking an ambiguous, high-level problem and breaking it into the infrastructure needed to solve it. It is not about one right answer: the interviewer watches how you handle trade-offs and communicate. Most entry-level software roles do not include one, though there are exceptions, and it becomes common at mid-level and heavily weighted for senior roles (source: Hello Interview introduction).
- Requirements (5 minutes). List three to five functional features, then the non-functional needs: scale, latency, availability and whether stale reads are acceptable. Ask the read-to-write ratio and say what is out of scope.
- Estimates (4 minutes). Turn users into requests per second, storage and bandwidth, using round numbers. The goal is to decide whether one database is enough, not to be exact.
- API (5 minutes). Name the endpoints or calls, inputs and outputs, authentication and pagination. Writes that can be retried need an idempotency key.
- Data model (5 minutes). List entities, keys and indexes, and pick SQL or NoSQL from the access patterns, not habit. See types of databases explained.
- High-level design (10 minutes). Draw clients, a load balancer, services, a database, a cache, a queue and an object store as needed, then follow one request end to end.
- Deep dive (10 minutes). Pick the hardest part: a hot key, fan-out, double booking. Show the failure case and the fix.
- Trade-offs and wrap-up (4 minutes). Name what you gave up, how it fails, what you would monitor and what you would build next.
Hello Interview gives roughly 5 minutes to requirements, 5 to the API, 10 to 15 to the high-level design and 10 to deep dives. The System Design Primer uses four steps: use cases and constraints, high-level design, core components, then scaling. Pick one structure and rehearse it until it is automatic. This is the estimate step for a URL shortener, with assumed inputs:
# Practice assumptions for a URL shortener, not measured data.
new_urls_per_month = 100_000_000
read_to_write = 100
seconds_per_month = 30 * 24 * 3600
bytes_per_record = 500
years = 5
writes_per_sec = new_urls_per_month / seconds_per_month
reads_per_sec = writes_per_sec * read_to_write
records = new_urls_per_month * 12 * years
storage_tb = records * bytes_per_record / 1e12
print(f"writes/sec ~ {writes_per_sec:,.0f}")
print(f"reads/sec ~ {reads_per_sec:,.0f}")
print(f"records = {records:,}")
print(f"storage ~ {storage_tb:.1f} TB over {years} years")
print(f"base62, 7 chars = {62**7:,} codes; 6 chars = {62**6:,}")About 39 writes and 3,858 reads per second is easily one database plus a cache, and 3 TB over five years is modest. A 7-character base62 code gives about 3.5 trillion combinations, so 6 characters (about 57 billion) already outlast 6 billion records. Saying this aloud shows why you do not shard on day one.
Core concepts, one line each, with a free place to learn
| Concept | One-line definition | Free place to learn |
|---|---|---|
| Load balancing | Spreads requests across servers by a rule such as round robin or least connections, and skips unhealthy servers | nginx load balancing guide |
| Caching | Keeps hot data in fast memory to cut latency and database load, at the price of stale data and invalidation | Hello Interview: caching |
| Sharding | Splits one dataset across several databases by a key so no machine holds it all; cross-shard queries get harder | Hello Interview: sharding, ByteByteGo: 7 strategies to scale a database |
| Replication | Copies data to other nodes for read scale and failover; with asynchronous copies a follower can lag | PostgreSQL replication docs |
| Message queues | Let a producer hand work to consumers later; delivery is often at-least-once, so consumers must handle duplicates. See applications of queues | Amazon SQS standard queues, Kafka introduction |
| CAP and consistency | During a network partition you choose between consistency (reads see the latest write or an error) and availability (every request gets an answer) | System Design Primer: availability vs consistency |
| Rate limiting | Caps requests per user or key to protect a service; a token bucket allows bursts at a steady average, and rejected calls get HTTP 429 | Stripe: scaling your API with rate limiters |
| CDN | A group of servers in many locations that hold copies of content close to users | MDN glossary: CDN |
| Idempotency | An operation that gives the same result when repeated; a client-supplied key makes a retried payment safe | Stripe idempotent requests, AWS: safe retries |
| Consistent hashing | Places keys and servers on a ring so adding a server moves only a small share of keys | Hello Interview: consistent hashing, Dynamo paper |
What is free and what is paywalled, checked on 11 November 2026 without logging in:
| Resource | Free | Paywalled or paid |
|---|---|---|
| System Design Primer | The whole repository: concepts, 8 worked system design questions, 6 object-oriented design questions, Anki decks. Licence CC BY 4.0 | Nothing |
| Hello Interview | The delivery framework, core concepts such as caching, sharding and CAP, and breakdowns including Bitly, Dropbox, Ticketmaster, News Feed, WhatsApp, Uber and a distributed rate limiter | Pages marked with a lock, for example Payment System, Notification System, Numbers to Know and some patterns; Guided Practice. Premium is optional and its one-month plan was listed at ₹3,199 on 11 November 2026 |
| ByteByteGo | A weekly newsletter issue on Saturdays and a public library of visual guides | Extra newsletter issues for premium members and the courses; the site says you can preview a course before buying. Alex Xu's System Design Interview books are sold separately |
| Engineering blogs | Stripe, the AWS Builders' Library and Discord opened without a login | Nothing found |
Skip unofficial downloads that turn up for searches such as 'system design interview pdf'. Alex Xu's books and the ByteByteGo courses are commercial products, and the free sources above are enough for this plan.
Ten classic problems: key decisions and pitfalls
| Problem | Key design decisions | Common pitfalls | Free walkthrough |
|---|---|---|---|
| URL shortener | Make a 7-character base62 code from a counter or ID service; map code to URL in a key-value or SQL table; cache hot codes; choose 301 or 302 | Truncated hashes collide; one counter becomes a bottleneck; a 301 can be cached by browsers, so later clicks never reach your analytics | Hello Interview: Bitly |
| Rate limiter | Token bucket or sliding window, enforced at the gateway, counters in a shared store such as Redis, reply 429 with Retry-After | Per-server counters let users exceed the limit; read-then-write races; no decision on failing open or closed | Hello Interview: rate limiter |
| Chat | Persistent WebSocket connections, a registry of which server holds each user, messages stored by conversation and time, acknowledgements and retries | Ordering across devices, huge groups, hot partitions on one busy channel, lost messages on reconnect | Hello Interview: WhatsApp |
| News feed | Fan-out on write (precompute each follower's feed) or on read (merge at request time); most designs mix both; cache feeds | Accounts with millions of followers make write fan-out slow; stale feeds after a delete or unfollow | Hello Interview: News Feed |
| Notification service | Accept events, check user preferences, queue per channel (push, SMS, email), workers call providers with back-off and an idempotency key | Duplicate sends after a retry, one slow provider blocking the rest, no priority lane for one-time passwords, ignoring opt-outs | None free found (Hello Interview's is Premium) |
| File storage | Split files into chunks, keep blobs in object storage and metadata in a database, upload with pre-signed URLs, sync only changed chunks | Proxying big uploads through app servers, no resumable upload, edit conflicts, metadata and blobs drifting apart | Hello Interview: Dropbox |
| Ride matching | Index driver locations by grid cell (geohash, S2 or H3), keep live positions in memory, search nearby cells, assign with an atomic claim | Location writes hitting a disk database, edge-of-cell misses, assigning one driver twice, hot cells in busy areas | Hello Interview: Uber |
| Ticket booking | Hold a seat with a short expiry, confirm after payment, prevent double booking with a row lock or unique constraint, add a waiting room for rushes | Check-then-insert races, holds that never expire, releasing a seat whose payment actually succeeded | Hello Interview: Ticketmaster |
| Search autocomplete | Serve from a prefix structure such as a trie built offline from query logs, cache by prefix, debounce on the client, refresh ranking in batches | Computing top suggestions on every keystroke, updating the index on the read path, unfiltered unsafe suggestions | None free found (a paid ByteByteGo chapter) |
| Payment or UPI-style flow | An idempotency key per attempt, explicit states with a pending state when a bank is silent, a status query instead of blind retries, an append-only double-entry ledger, daily reconciliation | Treating a timeout as failure and charging twice, updating two balances outside one transaction, no reversal path | None free found (Hello Interview's is Premium) |
Notes on specific rows. A 301 is a permanent redirect that browsers may cache, while a 302 keeps every click visible to you (RFC 9110). Rate-limited replies use status 429 and may carry a Retry-After header (RFC 6585). Discord reported hot partitions in its message store when one channel got heavy traffic. PostgreSQL's SELECT ... FOR UPDATE supports SKIP LOCKED, which lets workers pass over rows another transaction holds.
For the payment row, a simplified Indian model helps. RBI's August 2022 discussion paper lists the UPI participants as payer and payee payment service providers, the remitter bank, the beneficiary bank, NPCI and third-party app providers, with real-time fund movement and deferred net settlement between banks. RBI's 2019 failed-transaction circular says a UPI debit with no credit to the beneficiary must be auto-reversed by the beneficiary bank by T+1, with ₹100 a day owed after that. This is an interview model, not NPCI's internal design.
Two small components you can run
Two building blocks are small enough to sketch in an interview and to run here.
A token bucket rate limiter
The bucket holds up to 5 tokens and gains 1 per second. A burst of 7 requests at the same instant gets 5 through. One second later one request passes and the next is rejected. After a long gap the bucket is full again, so 5 of the next 7 pass:
class TokenBucket:
"""Allow `rate` requests per second on average, with bursts up to `capacity`."""
def __init__(self, capacity, rate):
self.capacity, self.rate = capacity, rate
self.tokens, self.last = float(capacity), 0.0
def allow(self, now):
# Refill for the time that has passed, never above capacity.
self.tokens = min(self.capacity, self.tokens + (now - self.last) * self.rate)
self.last = now
if self.tokens >= 1:
self.tokens -= 1
return True
return False
bucket = TokenBucket(capacity=5, rate=1) # 1 token per second, burst of 5
print("t=0, 7 quick requests:", [bucket.allow(0) for _ in range(7)].count(True), "allowed")
print("t=1, 1 request:", bucket.allow(1)) # one token has dripped back
print("t=1, 1 more request:", bucket.allow(1)) # the bucket is empty again
print("t=10, 7 quick requests:", [bucket.allow(10) for _ in range(7)].count(True), "allowed")In production the bucket lives in a shared store and the refill-and-take step must be atomic, otherwise two servers can both spend the last token.
Consistent hashing with virtual nodes
With plain hash % N, going from 3 to 4 servers moves about three quarters of all keys, which empties every cache at once. On a ring, only the keys that now belong to the new server move. Output of the program below: 2,448 of 10,000 keys move on the ring, all of them to D, against 7,463 with modulo.
import bisect, hashlib
def h(text):
return int(hashlib.md5(text.encode()).hexdigest(), 16)
class Ring:
def __init__(self, nodes, vnodes=100):
self.points = sorted((h(f"{n}#{i}"), n) for n in nodes for i in range(vnodes))
self.keys = [p for p, _ in self.points]
def node_for(self, key):
i = bisect.bisect(self.keys, h(key)) % len(self.points) # next point clockwise
return self.points[i][1]
keys = [f"user:{i}" for i in range(10000)]
before = Ring(["A", "B", "C"])
after = Ring(["A", "B", "C", "D"])
moved_ring = sum(before.node_for(k) != after.node_for(k) for k in keys)
nodes3, nodes4 = ["A", "B", "C"], ["A", "B", "C", "D"]
moved_mod = sum(nodes3[h(k) % 3] != nodes4[h(k) % 4] for k in keys)
print("ring: keys moved when D joins:", moved_ring, "of", len(keys))
print("hash % N: keys moved when D joins:", moved_mod, "of", len(keys))
print("keys now on D:", sum(after.node_for(k) == "D" for k in keys))What changes for freshers and seniors, and a 4-week plan
| Level | What usually changes | What to practise |
|---|---|---|
| Fresher or campus | Rounds often focus on low-level design (classes and relationships) and data structures rather than distributed systems. Some companies still ask a basic 'how would you scale this' question | LRU cache, parking lot, chat classes, tic-tac-toe, a rate limiter as classes; the OOP explainer and data structures and algorithms |
| 2 to 5 years | A system design round becomes common from mid-level. Cover the basics well and go deep on one part | The ten problems above, an API and data model for each, and one past project of yours explained as a design |
| 5 years and above | The round carries heavy weight at senior level. You lead the conversation, quantify, and defend trade-offs, failure modes and cost | Deep dives, capacity numbers, operations, migrations. See SDE levels for how titles map to scope |
The System Design Primer's object-oriented section lists hash map, LRU cache, call center, deck of cards, parking lot and chat server as practice questions. These are our reading of typical formats, since no company publishes statistics. Hello Interview says that if the topic is new you can spread preparation over three to four weeks:
| Week | Focus | Output |
|---|---|---|
| 1 | Foundations: HTTP and DNS, SQL versus NoSQL, indexes, API design, estimates. Use the Primer index and Hello Interview's networking, API and data modeling pages | A one-page cheat sheet of the ten concepts and three timed estimates |
| 2 | Building blocks: caching, load balancing, replication, sharding, queues, CAP, rate limiting, CDN. Run both Python demos and read the backend developer roadmap for the layers around them | Each concept explained in 60 seconds without notes |
| 3 | Problems under a 45-minute timer: URL shortener, rate limiter, chat, news feed, then notifications and file storage. Compare with a free walkthrough afterwards | Six designs on paper and a list of your repeated gaps |
| 4 | Harder problems (ride matching, ticket booking, payments, autocomplete) and two mock interviews with a friend. Freshers swap two sessions for low-level design problems | Two recorded mocks and a fixed list of trade-off phrases you trust |
Keep practising code in parallel: coding rounds usually come first, so data structures and algorithms and a language question bank such as the Java interview questions still matter.
Frequently asked questions
How do I prepare for a system design interview?
Learn the ten core concepts, then practise ten classic problems under a 45-minute timer: requirements, estimates, API, data model, high-level design, deep dive and trade-offs. Compare each attempt with a free walkthrough and note repeated gaps. Two mock interviews with a friend matter more than reading a fifth article.
How long does it take to prepare for a system design interview?
Hello Interview suggests three to four weeks if system design is new to you, and under a week for people who already know the concepts. The four-week plan above fits an hour or two a day alongside coding practice. Ask the recruiter for more time if the date is close.
Do freshers get system design interview questions?
Hello Interview says most entry-level software roles do not include a system design interview, though there are exceptions. Freshers more often face low-level design and data structures questions. Prepare class design problems first, and learn the core concepts so a basic scaling question does not catch you out.
What are the most common system design interview questions?
The same families recur: a URL shortener, rate limiter, chat system, news feed, notification service, file storage, ride matching, ticket booking, search autocomplete and a payment flow. The System Design Primer and Hello Interview list similar problems. No company publishes its question bank, so this list is our reading.
Are Hello Interview and ByteByteGo free?
Partly, as of 11 November 2026. Hello Interview's delivery framework, core concepts and several breakdowns open without login, while pages marked with a lock need Premium. ByteByteGo has a free weekly newsletter issue and public visual guides, but its courses are paid and Alex Xu's books are sold separately. The System Design Primer is fully free.
What is the difference between high-level design and low-level design?
High-level design chooses components and how they communicate: services, databases, caches and queues, with scale and failure in mind. Low-level design shapes the code inside one component: classes, interfaces, relationships and patterns such as a parking lot or LRU cache. Freshers usually meet low-level design first.
Sources checked
- Hello Interview introduction: what the round tests, levels, 3 to 4 weeks, lock icon for premium
- Hello Interview delivery framework and minute split
- System Design Primer: free, CC BY 4.0, interview steps, worked questions
- Token bucket and four limiter types at Stripe
- Idempotency keys
- RBI discussion paper on charges in payment systems, 17 Aug 2022: UPI participants and settlement
- RBI circular 20 Sep 2019 on failed transactions and turnaround time
- HTTP 301 and 302 semantics
- HTTP 429
- Dynamo paper: consistent hashing
Learn this with mentors
Programmes for builders and engineers with admissions open: live classes, mentors and project work.


