Skip to content

Note system design

All posts
Nov 16, 202612 min readsystem design · technical interviews · tech jobs · developer careerRead in:ENID

How to Prepare for a System Design Interview: A Practical Guide for Developers

System design rounds run 45 to 60 minutes and grade how you think, not what you memorize. A practical guide to the four evaluation axes, the seven building blocks, a 45-minute delivery framework, and a 10-problem practice plan.

Two women discussing an API flow at a whiteboard, preparing for a system design interview. Photo by ThisIsEngineering on Pexels.

The system design interview is the round that decides senior engineering loops. You get an open-ended prompt, a whiteboard, and 45 to 60 minutes to design a system that could serve millions of users. There is no single correct answer, and the interviewer knows it. What they are grading is how you frame an ambiguous problem, reason about trade-offs, and communicate a design that holds up under pressure. The good news is that this round is far more trainable than it looks. The same patterns, building blocks, and frameworks show up again and again, and a structured preparation plan turns a scary blank whiteboard into a familiar exercise. This guide walks through that plan: what the round actually tests, the fundamentals and building blocks to master, a minute-by-minute framework for the interview itself, and a practice plan built around ten classic problems.

Key Takeaways

>

System design rounds typically run 45 to 60 minutes and grade four axes: problem solving, solution design, technical excellence, and communication.

Preparation has four steps: understand what is assessed, refresh the fundamentals, master seven building blocks, then work backwards from common problems.

Seven components cover about 90% of interview designs: compute, database, cache, message queue, load balancer, blob storage, and CDN.

Run the round on a clock: about 5 minutes on requirements, 10 on high-level design, 20 to 25 on deep dives, and the rest on trade-offs and wrap-up.

Practice 5 to 7 classic problems end to end, out loud and timed, and the underlying patterns start repeating.

Always quantify. A design decision stated with a QPS, latency budget, or storage estimate is worth more than a perfect diagram with no numbers.

If you are preparing for the whole interview loop, not just this round, start with the companion guide: How to Pass Technical Interviews: A Practical Guide for Developers. And if your resume is what got you the interview in the first place, this one covers the other end of the funnel: How to Write a Tech CV That Passes ATS and Gets Read by Humans.

What the System Design Interview Actually Tests

A system design interview evaluates your ability to architect complex, scalable systems that solve real-world problems. Unlike a coding interview, which tests algorithms, this round tests technical breadth, communication clarity, and decision-making under ambiguity. The interviewer is not looking for a perfect answer, because there usually is not one. They want to see how you frame the problem, reason about trade-offs, and think about scalability and performance, according to Hello Interview, whose author has conducted more than 500 system design interviews.

Across companies, candidates are judged on permutations of the same four axes, per Hello Interview:

Evaluation axis

What the interviewer is watching for

Problem solving

How well you identify, understand, and prioritize the core challenges in a system

Solution design

Whether you can create a scalable architecture while balancing performance, maintainability, and cost trade-offs

Technical excellence

Depth of technical knowledge and mastery of relevant tools and best practices

Communication

How clearly you explain complex technical concepts and design decisions

There are a few flavors of the round. Product design prompts, such as "design Uber's backend", and infrastructure design prompts, such as "design a rate limiter", account for the vast majority of interviews. Object-oriented design and frontend design rounds exist too, but the preparation in this guide targets the first two flavors, as Hello Interview recommends.

The round is also calibrated to your target level. At L4, or SDE II, you design a single service with clean APIs and one or two scaling axes. At L5, or SDE III, the design adds multi-service coordination, explicit consistency choices, and operational concerns. At L6 and above, you are expected to handle multi-region, multi-tenant, and platform-level concerns, where your design becomes infrastructure other teams build on. A common calibration failure is producing a design at the wrong level, so match your depth to your target, according to LeakCode.

Step 1: Refresh the Fundamentals

Before touching any practice problem, make sure the fundamentals are solid. Most guides overwhelm you with rarely used theorems. The short list below is what actually matters, and it follows the structure in Hello Interview.

Storage. Be able to discuss relational databases, with normalized tables and relationships, versus document stores, with nested JSON-like structures, and key-value stores, with simple lookup mechanisms. Know ACID properties for transactional systems versus BASE principles for distributed databases, and be ready to say when each storage paradigm fits based on access patterns and consistency requirements.

Scalability. Be comfortable explaining vertical scaling, beefier machines, versus horizontal scaling, more machines. Know read and write segregation, partitioning and sharding, load balancing algorithms, and consistent hashing for distributing traffic and data.

Networking. Know HTTP and HTTPS, TCP versus UDP, DNS resolution, and API design. Be able to differentiate REST, GraphQL, and gRPC, and understand the role WebSockets and server-sent events play in real-time communication. If the networking basics feel rusty, the companion explainers on this blog cover REST API Explained and WebSockets Explained.

Latency, throughput, and capacity estimation. Memorize approximate latency numbers for common operations, because every design decision in the round is argued with them. The widely cited table, originally compiled by Jeff Dean and updated by Peter Norvig, puts an L1 cache reference at about 1 nanosecond, a main memory reference at about 100 nanoseconds, an SSD random read at about 150 microseconds, a round trip within the same datacenter at about 500 microseconds, and a cross-continent round trip at about 150 milliseconds, as summarized in LeakCode and the System Design Playbook. The same sources give a useful capacity rule: a single modern server typically handles 10,000 to 50,000 queries per second for simple endpoints, and 1,000 to 5,000 per second for endpoints that hit a database.

Fault tolerance. Failures are inevitable in distributed systems, so your design must include replication, failure detection, and redundancy at the server, rack, and datacenter levels, with graceful recovery.

The CAP theorem. In a network partition, a distributed system can guarantee only two of consistency, availability, and partition tolerance. Since partitions are inevitable, the practical choice is CP or AP. The rule of thumb from Hello Interview is simple: you need strong consistency for things like ticket booking or banking, and eventual consistency is fine for almost everything else.

Step 2: Master the Seven Building Blocks

Think of system design as Lego for engineers. You only need to know which pieces exist. Seven components will get you about 90% of the way to solving just about any interview problem, according to Hello Interview.

Building block

Purpose

Server and compute

Executes business logic, as a monolith, microservice, or serverless function

Database

Persists structured data, relational, document, key-value, or columnar

Cache

Speed layer, such as Redis or Memcached, with cache-aside, read-through, or write-through patterns

Message queue

Async communication and back-pressure, such as Kafka, RabbitMQ, or SQS

Load balancer

Distributes traffic with round-robin, least-connections, or consistent hashing

Blob storage

Unstructured objects, such as S3 or GCS, with lifecycle policies

CDN

Edge caching to cut latency and protect the origin

Master the pros, cons, and common failure modes of each. You do not need encyclopedic knowledge of twenty databases. You need to be able to say, for one concrete scenario, why you picked Postgres over DynamoDB, or Redis over Memcached, and what breaks first when that choice is pushed to 10x scale.

Step 3: Learn a 45-Minute Delivery Framework

The most common reason candidates fail is not a weak design. It is running out of time with the deep dive never started. System design rounds typically run 45 to 60 minutes, and the time split below, from LeakCode, keeps you on track.

Phase

Time

What to deliver

Requirements gathering

0 to 5 minutes

Functional and non-functional requirements, plus scale estimates: daily active users, queries per second, storage

High-level design

5 to 12 minutes

Boxes-and-arrows architecture: clients, load balancer, application servers, database, cache

Deep dive

12 to 35 minutes

One or two hard components in depth: schema and sharding, caching strategy, queue design, CDN for media

Trade-offs and bottlenecks

35 to 42 minutes

What breaks first at 10x scale, failure modes, and what you would change

Wrap-up

42 to 45 minutes

Summary of the design, open questions, and an invitation for feedback

A related six-step version, called RAPID-S in the System Design Playbook, adds an explicit API step between requirements and high-level design: requirements in 5 minutes, API in 5, plumbing in 10, internals in 15, deep dives in 5, and scale plus reliability in 5. Either version works. Pick one and rehearse it until the clock feels automatic.

Three discipline rules matter more than the exact split. First, always quantify: how many queries per second, how much storage, what latency budget. Second, never jump to distributed solutions without establishing a simple single-server baseline first. Third, keep the diagram clean: start with a simple box-and-arrow sketch and add detail as you discuss each component. Drawing the final architecture first hides your thinking, and the interviewer wants to see how the design evolves through the conversation, per LeakCode.

Step 4: Work Backwards From Ten Classic Problems

Passive consumption does not prepare you for this round. Watching videos and reading breakdowns only goes so far. The effective method is to work bottom-up from common problems, trying each one yourself with a timer before reading any solution. After the first three or four problems, start solving on your own, and by the time you have done five or six, the patterns become intuitive, because each new challenge is usually a recombination of familiar elements, according to Hello Interview.

The ten problems below, in this order, are the recommended sequence from Hello Interview:

  1. Design a URL shortener (Bitly). Tests hashing, databases, and caching.

  2. Design Dropbox. Tests file storage, synchronization, and metadata management.

  3. Design Ticketmaster. Tests concurrency, race conditions, and transactional integrity.

  4. Design a news feed. Tests content delivery, personalization, and real-time updates.

  5. Design WhatsApp. Tests real-time communication, presence detection, and message delivery.

  6. Design LeetCode. Tests code execution environments, scaling compute, and security.

  7. Design Uber. Tests geospatial indexing, matching algorithms, and real-time updates.

  8. Design a web crawler. Tests distributed systems, scheduling, and politeness policies.

  9. Design an ad click aggregator. Tests high-throughput event processing and analytics.

  10. Design Facebook post search. Tests indexing, ranking, and search optimization.

A second, independent list from LeakCode, based on its database of real interview reports, overlaps heavily: design a URL shortener, design the Twitter or X timeline, design a rate limiter, design a notification system, design a distributed key-value store, design the YouTube video upload and streaming pipeline, and design a ride-sharing service. The overlap is the point. Practice 5 to 7 of these end to end before your interview, and do them out loud. The goal is pattern recognition: a URL shortener and a key-value store are both write-heavy with simple reads, while Twitter and YouTube both involve fan-out. Recognizing the underlying pattern in the first two minutes shapes the entire design direction.

For a study timeline, the guide from DodaTech suggests 40 to 60 hours over 4 to 8 weeks for senior roles, with at least 10 problems practiced with a timer and at least 3 mock interviews with peers or on platforms like Pramp. Treat that as a planning estimate, not a rule. What matters is that the practice is timed, spoken out loud, and followed by a review of where you lost time or missed a trade-off.

Common Mistakes That Cost Candidates the Round

Most failures in this round are avoidable, and they cluster around a short list, per LeakCode:

  • Jumping to distributed solutions without establishing the single-server baseline first. A candidate who confidently designs a single-server solution will fail if they never ask about scale, but the reverse, microservices for a thousand users, fails just as fast.

  • Not asking about scale before designing. If you do not know the daily active users, the read-to-write ratio, or the latency budget, you are guessing, and the interviewer can tell.

  • Spending too long on requirements. More than 10 minutes on clarification leaves no time for the deep dives, which is where the strongest signals live.

  • Designing without quantifying. "We will add a cache" is a claim. "At 10,000 reads per second with a 95% hit rate, the cache cuts database load to 500 queries per second" is a design decision.

  • Never discussing trade-offs. Every choice gives something up. Name what you gave up, and say under what conditions you would choose differently.

  • Fighting the whiteboard. For virtual on-sites, the shared whiteboard tool varies, from Excalidraw to CoderPad to Google Slides. Practice on the actual platform if the recruiter tells you which one, because reports tag lost time fighting the whiteboard as a common failure mode.

The Week Before the Interview

Preparation peaks in the final week, and the work shifts from learning to rehearsing. Run two or three full mock interviews with a peer, timed at 45 minutes, on problems you have not solved before. Record yourself if you can, and listen for rambling, long silences, and moments where you stopped narrating your thinking. Revisit the latency numbers and the seven building blocks the night before, and re-read your own notes on the two or three problems where you struggled most. The day of the interview, arrive early, confirm the whiteboard tool, and remember the format: the round is a whiteboard conversation, not a quiz. Interviewers are evaluating how you think, not just what you produce, as the Apple system design guide puts it.

One last mindset shift helps. A system design interview is not a test of whether you know the right answer. It is a test of whether you can think through an ambiguous, high-scale engineering problem in a structured way. Reasoning matters more than conclusions, and a candidate who asks about scale, identifies the right bottlenecks, and articulates the trade-offs between SQL and NoSQL will pass even if they choose a suboptimal database, according to LeakCode. Bring a framework, bring numbers, talk out loud, and the whiteboard stops being scary.

Frequently Asked Questions

How long is a system design interview round?

System design rounds are typically 45 to 60 minutes. A good time split is 5 to 8 minutes on requirements clarification, 5 to 10 minutes on high-level design, 20 to 25 minutes on deep dives into hard components, and 5 to 10 minutes on trade-offs and scaling. Do not spend more than 10 minutes on requirements, or you run out of time for the deep dives, according to LeakCode.

How many hours should I study for a system design interview?

For senior roles, plan 40 to 60 hours over 4 to 8 weeks, with at least 10 problems practiced with a timer and at least 3 mock interviews, per DodaTech. Mid-level candidates targeting their first system design round can often prepare in less time, because the expected depth is a single service rather than a multi-region platform. The honest answer is that timed, spoken practice matters more than total hours.

Do new graduates get system design interviews?

Rarely. New graduates are usually assessed on coding and fundamentals instead. System design rounds appear from mid-level roles upward, and their weight grows with seniority. At L4, expect one 45-minute round on a single service. At L5 and above, expect deeper, broader designs with explicit consistency and operational reasoning.

What is the best book for system design interview preparation?

The most cited starting point is System Design Interview: An Insider's Guide by Alex Xu, volumes 1 and 2, which the System Design Playbook lists among its canonical sources alongside the system-design-primer repository and ByteByteGo. Pair the book with timed practice on the ten classic problems in this guide, since reading alone does not build the skill of designing out loud.

Should I memorize specific technologies or focus on concepts?

Focus on concepts. Interviewers care that you can justify a choice, not that you named the trendiest tool. Know one database, one cache, one queue, and one load balancing strategy deeply, including their failure modes, and you can adapt that knowledge to almost any prompt. The boring, proven tool, Postgres, Redis, Nginx, or Kafka, beats the exotic one until measurements force a change, as the System Design Playbook advises.

Baca artikel ini dalam Bahasa Indonesia: Cara Mempersiapkan Interview System Design: Panduan Praktis untuk Developer

Tags: system design · technical interviews · tech jobs · developer career

All posts