Skip to content
Home/Resources/Software Development/System design interview preparation
Interview prep · Software Development

System Design Interview Preparation: A Free 45-Minute Framework, 10 Classic Problems and a 4-Week Plan

By Younus FardeenUpdated 11 Nov 202614 min read
Short answer

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.

  1. 1Requirementsscope, scale, 5 min
  2. 2Estimatesload and storage, 4 min
  3. 3APIendpoints, 5 min
  4. 4Data modelentities and keys, 5 min
  5. 5High-level designboxes and flow, 10 min
  6. 6Deep diveone bottleneck, 10 min
  7. 7Trade-offsfailures and wrap-up, 4 min
A 45-minute split. The minutes are a guide, and the interviewer may steer you.

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).

  1. 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.
  2. 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.
  3. API (5 minutes). Name the endpoints or calls, inputs and outputs, authentication and pagination. Writes that can be retried need an idempotency key.
  4. 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.
  5. 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.
  6. Deep dive (10 minutes). Pick the hardest part: a hot key, fan-out, double booking. Show the failure case and the fix.
  7. 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

ConceptOne-line definitionFree place to learn
Load balancingSpreads requests across servers by a rule such as round robin or least connections, and skips unhealthy serversnginx load balancing guide
CachingKeeps hot data in fast memory to cut latency and database load, at the price of stale data and invalidationHello Interview: caching
ShardingSplits one dataset across several databases by a key so no machine holds it all; cross-shard queries get harderHello Interview: sharding, ByteByteGo: 7 strategies to scale a database
ReplicationCopies data to other nodes for read scale and failover; with asynchronous copies a follower can lagPostgreSQL replication docs
Message queuesLet a producer hand work to consumers later; delivery is often at-least-once, so consumers must handle duplicates. See applications of queuesAmazon SQS standard queues, Kafka introduction
CAP and consistencyDuring 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 limitingCaps requests per user or key to protect a service; a token bucket allows bursts at a steady average, and rejected calls get HTTP 429Stripe: scaling your API with rate limiters
CDNA group of servers in many locations that hold copies of content close to usersMDN glossary: CDN
IdempotencyAn operation that gives the same result when repeated; a client-supplied key makes a retried payment safeStripe idempotent requests, AWS: safe retries
Consistent hashingPlaces keys and servers on a ring so adding a server moves only a small share of keysHello Interview: consistent hashing, Dynamo paper

What is free and what is paywalled, checked on 11 November 2026 without logging in:

ResourceFreePaywalled or paid
System Design PrimerThe whole repository: concepts, 8 worked system design questions, 6 object-oriented design questions, Anki decks. Licence CC BY 4.0Nothing
Hello InterviewThe delivery framework, core concepts such as caching, sharding and CAP, and breakdowns including Bitly, Dropbox, Ticketmaster, News Feed, WhatsApp, Uber and a distributed rate limiterPages 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
ByteByteGoA weekly newsletter issue on Saturdays and a public library of visual guidesExtra 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 blogsStripe, the AWS Builders' Library and Discord opened without a loginNothing 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

ProblemKey design decisionsCommon pitfallsFree walkthrough
URL shortenerMake 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 302Truncated hashes collide; one counter becomes a bottleneck; a 301 can be cached by browsers, so later clicks never reach your analyticsHello Interview: Bitly
Rate limiterToken bucket or sliding window, enforced at the gateway, counters in a shared store such as Redis, reply 429 with Retry-AfterPer-server counters let users exceed the limit; read-then-write races; no decision on failing open or closedHello Interview: rate limiter
ChatPersistent WebSocket connections, a registry of which server holds each user, messages stored by conversation and time, acknowledgements and retriesOrdering across devices, huge groups, hot partitions on one busy channel, lost messages on reconnectHello Interview: WhatsApp
News feedFan-out on write (precompute each follower's feed) or on read (merge at request time); most designs mix both; cache feedsAccounts with millions of followers make write fan-out slow; stale feeds after a delete or unfollowHello Interview: News Feed
Notification serviceAccept events, check user preferences, queue per channel (push, SMS, email), workers call providers with back-off and an idempotency keyDuplicate sends after a retry, one slow provider blocking the rest, no priority lane for one-time passwords, ignoring opt-outsNone free found (Hello Interview's is Premium)
File storageSplit files into chunks, keep blobs in object storage and metadata in a database, upload with pre-signed URLs, sync only changed chunksProxying big uploads through app servers, no resumable upload, edit conflicts, metadata and blobs drifting apartHello Interview: Dropbox
Ride matchingIndex driver locations by grid cell (geohash, S2 or H3), keep live positions in memory, search nearby cells, assign with an atomic claimLocation writes hitting a disk database, edge-of-cell misses, assigning one driver twice, hot cells in busy areasHello Interview: Uber
Ticket bookingHold a seat with a short expiry, confirm after payment, prevent double booking with a row lock or unique constraint, add a waiting room for rushesCheck-then-insert races, holds that never expire, releasing a seat whose payment actually succeededHello Interview: Ticketmaster
Search autocompleteServe from a prefix structure such as a trie built offline from query logs, cache by prefix, debounce on the client, refresh ranking in batchesComputing top suggestions on every keystroke, updating the index on the read path, unfiltered unsafe suggestionsNone free found (a paid ByteByteGo chapter)
Payment or UPI-style flowAn 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 reconciliationTreating a timeout as failure and charging twice, updating two balances outside one transaction, no reversal pathNone 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

LevelWhat usually changesWhat to practise
Fresher or campusRounds 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' questionLRU cache, parking lot, chat classes, tic-tac-toe, a rate limiter as classes; the OOP explainer and data structures and algorithms
2 to 5 yearsA system design round becomes common from mid-level. Cover the basics well and go deep on one partThe ten problems above, an API and data model for each, and one past project of yours explained as a design
5 years and aboveThe round carries heavy weight at senior level. You lead the conversation, quantify, and defend trade-offs, failure modes and costDeep 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:

WeekFocusOutput
1Foundations: HTTP and DNS, SQL versus NoSQL, indexes, API design, estimates. Use the Primer index and Hello Interview's networking, API and data modeling pagesA one-page cheat sheet of the ten concepts and three timed estimates
2Building 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 themEach concept explained in 60 seconds without notes
3Problems under a 45-minute timer: URL shortener, rate limiter, chat, news feed, then notifications and file storage. Compare with a free walkthrough afterwardsSix designs on paper and a list of your repeated gaps
4Harder problems (ride matching, ticket booking, payments, autocomplete) and two mock interviews with a friend. Freshers swap two sessions for low-level design problemsTwo 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

Learn this with mentors

Programmes for builders and engineers with admissions open: live classes, mentors and project work.

Continue learning

Roadmap

Backend developer roadmap

Pick a stack, then SQL, APIs, auth, queues and Docker, in order

Open →
Learning path

Data Structures and Algorithms learning path

Arrays to dynamic programming in order, with a problem plan.

Explainer

Applications of queue

Where queues are used: scheduling, BFS, buffers, with code.

Open →