11 Most-Asked System Design Interview Questions (+ answers)

By Max Serrano with input from the following coaches: Mark K . May 21, 2024

Young woman draws her system design diagram on whiteboard during system design interview

Below is a comprehensive list of system design questions asked by the top tech companies in software engineer, engineering manager, and TPM interviews.

To help you answer them, we've included answer outlines and design diagrams created by our engineering experts. We've also linked to the best prep resources.

Here's an overview of what we'll cover:

11 most common "Design X product" system design questions (for FAANG candidates)
System design "knowledge" interview questions (for Fresher candidates)
System design interview tips
How to prepare for system design interviews

Our thanks to our system design experts, Mark (ex-Google) and Pranav (ex-Meta) for their help with this guide.

Let's go!

Click here to practice system design interviews 1-on-1 with an ex-FAANG interviewer

Common FAANG system design interview questions ("Design X product")

Top companies like Google and Meta often ask candidates to design large-scale systems from scratch.

The 11 questions below were the most common out of over 350 system design interview questions that we collected from Glassdoor.com from FAANG candidates. They're listed roughly in order of frequency below (note: we've just made minor edits to the phrasing).

How would you design a social media app?
How would you design X game?
How would you design a parking lot?
How would you design a URL-shortening service?
How would you design a web cache?
How would you design autocomplete for a search engine?
How would you design an API?
How would you design a messaging app?
How would you design an online file-sharing system
How would you design an e-commerce store
How would you design a ride-hailing / delivery app

(Click here to skip to the list of common system design interview questions for fresher/junior candidates)

Let's dig into these:

1. How would you design a social media app?

For this question, you'll typically be asked to design a specific app, such as YouTube, Instagram, etc. For this example, we’ll assume the interviewer asked you to design Twitter, or X.com as it now is. Here are some considerations for answering this question:

Ask clarifying questions

Is the interviewer looking for a design of the core features, or a high-level overview of the whole service?
What are the constraints of the system?
What are your assumptions? (traffic distribution, number of active users and tweets, read vs write-heavy)

Design high-level

Back-of-the-envelope calculations: average KBs per tweet, size of new tweet content per month, read requests and tweets per second, etc.
High-level components: write, read, and search APIs; types of databases; SQL vs NoSQL; etc

Drill down on your design

Potential bottlenecks: adding a load balancer with multiple web servers, scalability issues, fanout service slowing down tweets and @replies, etc.
Components that you could dive into: how a user views the home timeline or posts a tweet, the intricacies of the database design, etc.

Bring it all together

Consider: does the final design address the bottlenecks you’ve identified? Does it meet the goals you discussed at the beginning of the interview? Do you have any questions for the interviewer?

For a full answer to this question, take a look at the video guide below from Success In Tech or this text guide from donnemartin on GitHub.

2. How would you design X game?

Another topic that comes up frequently is designing a classic game. The exact game you’ll be asked about varies, but here are some of the most common ones we’ve seen:

Tic-tac-toe
Chess
Boggle
Minesweeper
Cards/poker

Let’s walk through an example of how you could approach the problem if you were asked to design a chess game.

Ask clarifying questions

What are the rules of the game?
How many players are there? Are there spectators?
Do we need a timer? Are any other special functions required?

Design high-level

Possible classes for the game: board, piece, spot, etc.
Methods that will be required for things like moving pieces

Drill down on your design

Identify important attributes for each class, such as the grid coordinates and color of each spot
Define how the game will prevent illegal moves and recognize a victory

Bring it all together

Sense check your design, and confirm whether it has met all of the requirements you identified at the beginning of the interview

Some of the above considerations were inspired by this in-depth solution to the question, so feel free to check out that resource.

3. How would you design a parking lot?

For questions like these, interviewers are testing your skills in object-oriented design, to see whether you can apply technical thinking to physical objects.

Ask clarifying questions

Is this a multiple floor parking garage or a single level parking lot?
How many entry and exit points will be needed, and for what types of vehicles?
Are there monetary goals for this parking lot?

Design high-level

Possible use cases: customers parking and paying for their spot, admin managing the system, parking attendants maintaining the lot and helping customers, etc.
Possible classes of the system: ParkingLot, ParkingFloor, Account, ParkingTicket, Vehicle, etc.

Drill down on your design

How will you diagram specific activities? (e.g. customers paying for parking tickets, display panels showing available spots, etc.)
What are the required enums, data types, and constants of the eventual code for the parking lot system?

Bring it all together

Will this system meet the requirements you’ve laid out with the interviewer in the beginning of the session?

For a full answer to this question, take a look at this text guide from Educative.io. You may also find this video walk-through from Think Software useful:

4. How would you design a URL-shortening service?

URL shortening services like TinyURL, Bitly, etc. provide short link aliases that redirect to longer URLs. Here are some points of consideration to help you work out how to build this kind of system.

Ask clarifying questions

Will users be able to customize the URL?
How long do the URLs last before they expire?
What are the availability and latency requirements for this system?

Design high-level

Back-of-the-envelope calculations: estimate the traffic and storage needs per month, as well as bandwidth and memory requirements
Define the APIs (SOAP, REST, etc) as well as a general database schema (URL mappings and user data)

Drill down on your design

Consider tradeoffs: encoding actual URLs may turn out the same shortened URL for two different users who enter the same URL. System may not work for URLs with URL-encoding. Concurrency may cause problems, etc.
Where will you place load balancers, and how will you cache URLs?

Bring it all together

Is the system you’ve designed highly available, so that URLs will not break if the servers go down? Does it meet any potential business objectives laid out at the start of the interview?

For a full answer to this question, take a look at this text guide from Educative.io.

Are you getting invited to enough system design interviews? If not, you might want to use our free tech resume guide (with examples) to improve your resume.

5. How would you design a web cache?

A distributed web cache is key to many systems, so that the RAM of multiple machines can be accessed in a single in-memory store quickly and reliably. Let’s look at some general points that should help you build out a design.

Ask clarifying questions

Consider the functional and non-functional requirements: put (storing objects under a unique key), get (retrieving objects), scalability, availability, performance, etc.
Specify your assumptions: can we assume that put and get are strings?

Design high-level

Possible data structures for storing data: hash table, queues, doubly linked list
Consider different options to distribute the cache, as well as the benefits of each (e.g. dedicated cache clusters vs co-located caches)

Drill down on your design

Identify the tradeoffs of your choices: Maximum hash table size will prevent from adding more elements, shards may become “hot” (aka process more requests than others), etc.
Data replication could help with “hot” shard bottleneck

Bring it all together

Is the system you’ve designed fast, highly scalable, and available?

For a full answer to this question, take a look at the video guide below from System Design Interview.

6. How would you design autocomplete for a search engine?

If you’ve ever started typing something into a search engine, then you will have seen the suggested “autocomplete” options that are provided. This is also an interesting, and common, system design interview topic. Here are some points you could consider here:

Ask clarifying questions

What are the key features? (fast response time, high relevance, number of results, etc.)
What are the functional and non-functional requirements?

Design high-level

What data structure will you use to find suffixes and word completion, and how will you sort the solutions?
How will you store this data structure and connect it with the rest of the system? (Redis cache, database, hash table, API server, load balancer, etc.)

Drill down on your design

How would you modify the frequency of the system without compromising availability or increasing latency?
Consider the fault tolerance of the system - How would you store the already built trie data structure so that in case of failure the system can be restored?

Bring it all together

Is there any more optimization that you could do? Does the system meet the requirements laid out in the beginning of the interview?

For a full answer to this question, take a look at the video guide below from Narendra L.

7. How would you design an API?

APIs are kind of like the bridges that connect the roads of major software products. As a result, they are a central part of the system design of major apps like Instagram, YouTube, Twitter, etc.

Let’s say you were asked, very broadly, to design an API for a website. Here are some examples of how you could go about this:

Ask clarifying questions

Who/what will be using the API?
What is the purpose of the API?
What kind of information does the API need to pass?

Design high-level

Define how the API will be accessed by users (e.g. through a mobile app, website, etc.)
Consider the provider side of the API and the services/databases that will be accessible

Drill down on your design

Should an API gateway be used to improve security?
Will there be an authentication process to access the API?
Will you use a REST API or something different?

Bring it all together

Does your API meet all of the original requirements? Are there any additional considerations, or areas that could use further refinement?

To learn more about API design, check out this mock interview from Exponent, on designing the Twitter API:

8. How would you design a messaging app?

Real-time messaging apps are a common standalone product, or a built-in feature of larger systems. For this question, you might be asked to design a specific app, like WhatsApp, Facebook Messenger, or Telegram

Ask clarifying questions

What is the scale and profile of the user base?
What features should be incorporated into the messenger? (e.g. text, video, audio, read receipts, message encryption, etc.)
Should we focus on monetizing the system?

Design high-level

How many servers will this system need, and how will clients connect to them?
How will the senders and receivers of messages connect to the servers and database?
Where will the messages be stored, and for how long?

Drill down on your design

How will you scale the system, and where are the bottlenecks?
Deep dive into a component: sent, delivered, read notifications; push notifications; media sharing; database design; etc.

Bring it all together

Have you met the initial goals you and the interviewer laid out for the system?

If you were designing Telegram, your design might look something like this:

Design telegram - system design diagram

This diagram was created by Mark, ex-Google EM for 13 years, in a system design mock interview video.

9. How would you design a file-sharing system?

If you were interviewing at Google this question would probably be presented as "Design Google Drive" whereas elsewhere it might be "Design Dropbox."

You'll need to design a system that can scale to millions of users and handle petabytes of data.

Ask clarifying questions

What is the expected user base and usage patterns? (e.g., individual users, businesses, file sizes, frequency of uploads/downloads)
Are there any specific security requirements for file storage and sharing?
Should the service support file versioning, collaboration, and synchronization across devices?

Design high-level

Determine the overall system architecture, including client-server communication and storage components.
Define how users will access the file-sharing service (web interface, desktop applications, mobile apps) and how they will authenticate and authorize access.
Determine the storage infrastructure and consider options such as cloud storage, distributed file systems, or a combination based on performance, scalability, and data redundancy requirements.

Drill down on your design

Define the data model and storage system for storing files and metadata. Consider techniques like sharding or partitioning to distribute and handle large amounts of data efficiently.
Discuss how the file upload and download process will work, including any optimizations for large file transfers, resumable uploads, and efficient streaming.
Address synchronization challenges, including conflict resolution, file locking, and ensuring consistency across devices when files are modified or shared.

Bring it all together

Discuss how the system can scale to handle a growing user base, increased file storage, and concurrent file operations.
Consider fault tolerance mechanisms, such as data replication and backup strategies, to ensure data durability and availability.
Discuss potential performance optimizations, like caching frequently accessed files or leveraging content delivery networks (CDNs) for faster data delivery.
For extra points, address security measures, including encryption at rest and in transit, access controls, and user permissions to protect sensitive data.

For a full answer to this question, take a look at the video guide below by Alex, ex-engineering manager at Shopify.

10. How would you design an e-commerce store?

This question might take the form of "Design Amazon", "Design eBay", "Design FlipKart", etc.

Your online shopping system will need to store an inventory of products with lots of categories, allowing customers to search through them and make purchases. You'll also need to think about how you handle the expanding load on the website and prevent it from crashing on key retail days.

Ask clarifying questions

Will the store be available globally or limited to specific regions?
Do we need any specific features or functionalities desired, such as reviews, recommendations, or personalized experiences?

Design high-level

Determine the overall architecture of the e-commerce store, including client-server communication, databases, and external integrations.
Define the user interfaces, including web, mobile, and potentially other platforms like voice assistants or smart devices.
Identify the core features, such as product catalog, search, shopping cart, payment processing, and order management.

Drill down on your design

Discuss the product catalog and inventory management system, including categories, attributes, pricing, and availability.
Address the search functionality, including features like auto-suggestions, filters, and sorting options.
Discuss the shopping cart and checkout process, considering guest checkout, saved carts, and various payment options.
Time permitting, consider the order management system, including order tracking, notifications, and returns/refunds handling.
For extra points discuss security measures, including encryption, secure payment processing, and protection against common vulnerabilities like cross-site scripting (XSS) or SQL injection.

Bring it all together

How well does your system meet the requirements? Is there anything you can do to refine it?
You might want to address internationalization and localization requirements, including multiple languages, currencies, and regional regulations.

To see an expert answer to the question, watch the video below - Gaurav Sen is the candidate and he's always great.

If you'd prefer to take a look at a written solution to the problem, check out this article on Medium.

11. Design a ride-hailing or delivery app

This question frequently appears as "Design Uber", "Design DoorDash", etc., substituting in whichever brand is prominent in the region you're interviewing in.

Let's take a look at an answer outline to "Design Uber".

Ask clarifying questions

Are we just focusing on Uber's main ride-hailing service?
Are there any specific features or requirements, such as real-time tracking, payment options, or driver-partner management?
Any existing infrastructure or partnerships to leverage?

Design high-level

Determine the overall architecture of the system, including client applications, backend services, databases, and external integrations.
Identify the core features, such as ride requests, driver allocation, real-time tracking, payments, and ratings/reviews.

Drill down on your design

Discuss the rider app functionality, including authentication, ride requests, trip history, real-time driver tracking, and fare estimation.
Address the driver app functionality, including driver registration, authentication, trip acceptance, navigation, and earnings tracking.
Discuss the backend services responsible for matching riders with available drivers, considering factors like proximity, driver ratings, and estimated arrival time.
You could also address the real-time tracking system, including location updates, route optimization, and handling unexpected events like traffic or road closures.
Or you could discuss the payment processing system, including multiple payment options, fare calculations, and integration with payment gateways.
For extra points, consider security measures to protect user data, prevent fraud, and ensure secure communication.

Bring it all together

Has the system met the requirements laid out?
Discuss how the system can handle challenges such as surge pricing during peak demand and incentivize drivers to meet increased rider demand.
Or you could touch on customer support features, such as in-app chat, support tickets, or phone support for issue resolution.
You might also want to mention potential integrations with external services, such as mapping/navigation providers, payment gateways, or carpooling solutions.

See a detailed written answer for "Design Uber back-end" in this Educative blog post.

System design "knowledge" questions (for fresher/junior engineers)

The second type of system design questions is “knowledge” questions to test your knowledge about key system design fundamentals, e.g. “How does caching work?”. These are more common in interviews when the candidate is a fresher/junior engineer.

As ex-Meta engineering manager Pranav explained to us, FAANG generally don't ask these more straightforward questions. However, these topics may come up when discussing the design choices and trade-offs associated with them as you do your main system design question.

Pranav, who has conducted over 200 engineering interviews over the course of his career, created the following list of ten system design knowledge questions.

1. What is consistent hashing and how does it work?

Consistent hashing is a technique used in distributed systems to distribute data across a cluster of nodes efficiently. Unlike traditional hashing, which can lead to massive data reshuffling when a node is added or removed, consistent hashing minimizes the amount of data that needs to be moved.

How it works:

Hash Space: Consider a circular hash space where each node and data item is assigned a position based on a hash function.
Node Assignment: Nodes (servers) are placed on this circle according to their hash values.
Data Assignment: Each piece of data is also hashed to a position on the circle. It is assigned to the nearest node in the clockwise direction.
Rebalancing: When a node is added or removed, only the data between the node and its predecessor/successor is affected, drastically reducing the amount of data moved compared to traditional hashing methods.

This method ensures that the load is balanced across the nodes and scales well as nodes are added or removed.

2. What is an API Gateway?

An API gateway is a server that sits between clients and backend services. It acts as a reverse proxy to accept all application programming interface (API) calls, aggregate the various services required to fulfill them, and return the appropriate result.

Key Functionalities:

Routing: Directs client requests to the appropriate backend services.
Composition: Combines responses from multiple services into a single response, which can reduce the number of client requests.
Security: Enforces authentication, authorization, and rate limiting, protecting backend services from malicious attacks and overuse.
Monitoring and Logging: Tracks API usage, logs requests and responses, and monitors performance to help identify and troubleshoot issues.
Load Balancing: Distributes incoming requests across multiple instances of backend services to ensure high availability and reliability.

By consolidating various functions into a single point, the API gateway simplifies client interactions and enhances system efficiency and security.

3. What is the difference between SQL and NoSQL?

SQL (Structured Query Language):

Schema: SQL databases use a fixed schema, where the structure of data (tables, rows, columns) must be defined before data can be inserted. This ensures data integrity and supports complex queries.
Transactions: They support ACID (Atomicity, Consistency, Isolation, Durability) properties, making them ideal for applications requiring reliable transactions, such as financial systems.
Examples: MySQL, PostgreSQL, Oracle Database.

NoSQL (Not Only SQL):

Schema: NoSQL databases have a flexible schema, allowing for the storage of unstructured or semi-structured data. They can accommodate a variety of data models, including document, key-value, wide-column, and graph stores.
Scalability: Designed for horizontal scaling, NoSQL databases handle large volumes of data and high traffic loads efficiently, making them suitable for big data applications and real-time web apps.
Transactions: Generally, NoSQL databases prioritize availability and partition tolerance over strong consistency (CAP theorem), offering eventual consistency.
Examples: MongoDB (document store), Redis (key-value store), Cassandra (wide-column store), Neo4j (graph database).

4. What is caching and what are different strategies around caching?

Caching involves temporarily storing copies of data in a cache, a high-speed storage layer, to improve data retrieval times and reduce the load on the primary data source.

Strategies:

Cache-aside (Lazy Loading): The application looks for data in the cache first. If the data isn't found, it's loaded from the database and then added to the cache. This approach ensures the cache only stores frequently accessed data but can lead to cache misses.
Write-through: Data is written to both the cache and the database simultaneously. This keeps the cache up-to-date with the database but can increase write latency.
Write-back (Write-behind): Data is written to the cache first and later persisted to the database asynchronously. This improves write performance but can lead to data loss if the cache fails before the data is written to the database.
Time-to-Live (TTL): Cached data is set to expire after a specified period. This strategy ensures stale data is periodically refreshed, balancing performance and data accuracy.
Eviction Policies: Determine which data to remove when the cache is full. Common policies include Least Recently Used (LRU), Most Recently Used (MRU), and Least Frequently Used (LFU).

Effective caching strategies can significantly improve system performance and scalability by reducing latency and the load on backend systems.

5. What is the difference between a row and columnar database?

Row Database:

Storage: Stores data row-by-row, which is efficient for transactional operations where the entire row is accessed or modified frequently.
Access Pattern: Ideal for applications with a high volume of write operations and those requiring complex transactional queries.
Examples: MySQL, PostgreSQL, Oracle Database.

Columnar Database:

Storage: Stores data column-by-column, which allows for efficient read operations, especially for analytical queries that involve aggregate functions on large datasets.
Access Pattern: Optimized for read-heavy workloads and OLAP (Online Analytical Processing) where queries often involve scanning large amounts of data.
Examples: Apache Cassandra, HBase, Google BigQuery.

6. What is a CDN and how is it helpful?

A Content Delivery Network (CDN) is a geographically distributed network of servers designed to deliver content to users more quickly and efficiently based on their location.

Benefits:

Reduced Latency: By caching content closer to the end-users, CDNs significantly reduce the distance data must travel, resulting in faster load times.
Improved Load Times: Static content like images, videos, and stylesheets are served from edge servers, alleviating the load on the origin server and speeding up page load times.
Reliability and Redundancy: CDNs provide redundancy by distributing content across multiple servers, ensuring high availability even if some servers fail.
Scalability: CDNs can handle large traffic spikes by distributing the load across many servers, preventing performance bottlenecks and downtime during high-traffic events.

CDNs are essential for enhancing the user experience on high-traffic websites and applications by ensuring fast, reliable, and scalable content delivery.

7. What's the difference between polling, long polling, WebSockets, and server-Sent Events?

Polling:

The client periodically sends requests to the server to check for new data. This approach is simple but can be inefficient, as it involves many unnecessary requests when there is no new data.

Long Polling:

The client sends a request to the server, and the server holds the request open until new data is available. Once new data is sent, the client immediately re-requests. This reduces latency compared to regular polling and is more efficient.

WebSockets:

WebSockets provide full-duplex communication channels over a single, long-lived connection. This allows for real-time, bidirectional communication between the client and server, making it ideal for applications like live chat and gaming.

Server-Sent Events (SSE):

The server sends automatic updates to the client over a single HTTP connection. SSE is simpler to implement than WebSockets for one-way data streams, such as live news feeds or real-time notifications.

Understanding these communication methods helps in selecting the right approach based on the requirements of real-time data transfer in applications.

8. What is data partitioning?

Data partitioning involves dividing a large database into smaller, more manageable pieces that can be distributed across different storage nodes or servers.

Types of Partitioning:

Horizontal Partitioning (Sharding): Divides data by rows, where each partition contains a subset of the rows. This approach is commonly used to scale out databases across multiple machines.
Vertical Partitioning: Divides data by columns, where each partition contains a subset of the columns. This can be useful for isolating frequently accessed columns to improve performance.
Range Partitioning: Distributes data based on a range of values, such as dates or numerical ranges, allowing for efficient query processing for range queries.
Hash Partitioning: Distributes data based on a hash function applied to one or more columns, ensuring even distribution and minimizing the risk of hotspots.

Data partitioning improves scalability, performance, and manageability of large databases, making it easier to handle growing data volumes and traffic.

9. What is a database index and how does it help?

A database index is a data structure that improves the speed of data retrieval operations on a database table by providing quick access to rows.

Benefits:

Fast Query Performance: Indexes significantly reduce the amount of data the database engine needs to scan, speeding up search and retrieval operations.
Types of Indexes:
- B-tree Indexes: Commonly used in most databases, they allow for quick searches, insertions, deletions, and sequential access.
- Hash Indexes: Provide constant-time lookup for equality comparisons but are not suitable for range queries.
- Full-text Indexes: Optimized for searching large text fields, useful for applications involving text search.
Trade-offs: While indexes enhance read performance, they can slow down write operations due to the overhead of maintaining the index.

Indexes are crucial for optimizing query performance, especially in large databases with complex queries.

10. What are load balancers?

Load balancers are devices or software that distribute incoming network traffic across multiple servers to ensure no single server becomes overwhelmed, thereby improving the overall availability and reliability of applications.

Types:

Hardware Load Balancers: Dedicated physical devices designed to balance loads at high performance levels

This is by no means a comprehensive list of all the system design topics you could be asked about. We recommend using our 9-part system design interview fundamentals series to dive deeper into certain areas ahead of your interview.

System design interview tips (from an ex-Google engineering manager)

Mark was engineering manager at Google for 13 years and has conducted hundreds of system design interviews during his career. He's now one of the top coaches on our platform, and has helped hundreds of candidates just like you ace their system design interviews.

We asked him for 10 tips to help you pass your system design interview - this is the list he came up with.

#Tip 1: Communicate efficiently

45 minutes is an artificially compressed time. You won't be used to working and talking about things at this speed and so you need to communicate with the interviewer efficiently. This takes practice. Make sure the interviewer can follow your design and your thought process.

#Tip 2: Scope the problem

You're often asked to design entire large-scale systems like Spotify or YouTube. In ~45mins this is impossible, so you need to scope the problem to a manageable size. Start by clarifying the requirements with your interviewer and making clear assumptions if details are vague. Focus on a specific, crucial part of the system, such as the backend architecture or a particular feature (e.g. if you were designing Spotify, this might be the music recommendation engine). Be ready to adjust your scope based on the interviewer's feedback.

#Tip 3: Start drawing ~15mins in

Drawing is an important visual aid to help the interviewer understand your answer. Try to start drawing around a third of the way into the interview. If you start drawing too soon, you probably won't yet fully understand the problem and you may go down the wrong track. If you start too late, you may run out of time to finish your design.

#Tip 4: Start with a simple design

Get to a working solution first, then iterate. Don't get sidetracked and add requirements that didn't exist in the question, these will complicate your design. You can always mention something and come back to it later. For example "we'll need to use caching here but I'll come back to that later."

Tip #5: Properly understand the problem

Engineers are trained to look for solutions but don't start going down this path too early. First, make sure you really understand what the problem is and what the objective is. Think about specific use cases and imagine you're calling your own APIs - this can help you catch assumptions you might have made.

#Tip 6 Practice, practice, practice!

There is a knowing and doing gap with system design interviews. Learning the theory and reading prep guides is great but you need to practice out loud with friends or experts, or at least record yourself and watch yourself back.

If you do some mock interviews, which are hugely helpful, ideally allow time for a long feedback and conversation afterward.

#Tip 7 Explain your thinking

Give your reasons as to why you're making each choice you do. Why did you choose one particular technology over another one? The interviewer wants to understand what's behind your thinking in order to assess your level of technical judgment.

#Tip 8 Get comfortable with the math

For FAANG companies, scale is important in system design interviews. That means you're going to have to do some back-of-the-envelope calculations early on in your design. Get used to calculating queries per second and the storage capacity needed.

Tip #9 Use the drawing tool efficiently

Try to find out which tool the company you're interviewing with will want you to use and make sure you're comfortable using it. Your drawing is a visual aid, it doesn't need to look pretty, but you do need to be able to create boxes, shapes and arrows quickly without having to think much about it.

#Tip 10 Utilize a range of prep resources

There are some great resources out there, make sure you use them, ideally both written and video content. There will be some differences of opinion as there is not one catch-all "recipe" for successful system design interviews, that's normal.

For more explanation around these tips, watch the full video with Mark.

How to prepare for system design interviews

As you can see from the complex questions above, there is a lot of ground to cover when it comes to system design interview preparation. So it’s best to take a systematic approach to make the most of your practice time.

Below, you’ll find a prep plan with links to free resources. You can also refer to our system design interview prep guide and our list of 19 system design interview tips from ex-interviewers.

Otherwise, let's start with preparation step 1.

1. Learn the concepts

There is a base level of knowledge required to be able to speak intelligently about system design. You don't need to know EVERYTHING about sharding, load balancing, queues, etc.

However, you will need to understand the high-level function of typical system components. You'll also want to know how these components relate to each other, and any relevant industry standards or major tradeoffs.

To help you get the foundational knowledge you need, we've put together a series of 9 system design concept guides. Here's the full list:

Network protocols and proxies, which make it possible for any networked computers to talk to each other, no matter where they are or what hardware or software they’re running.
Databases, integral components of the world’s biggest technology systems.
Latency, throughput, and availability, three common metrics for measuring system performance.
Load balancing, the process of distributing tasks over a set of computing nodes to improve the performance and reliability of the system.
Leader election algorithms, which describe how a cluster of nodes without a leader can communicate with each other to choose exactly one of themselves to become the leader.
Caching, a technique that stores copies of frequently used application data in a layer of smaller, faster memory in order to compute costs and to improve data retrieval times and throughput.
Sharding, the horizontal scaling of a database system that is accomplished by breaking the database up into smaller “shards,” which are separate database servers that all contain a subset of the overall dataset.
Polling, SSE, and WebSockets, techniques for streaming high volumes of data to or from a server.
Queues and pub-sub, mechanisms that allow a system to process messages asynchronously, avoiding bottlenecks and help the system to operate more efficiently.

We’d encourage you to begin by studying these topics, and once you understand the basics, you can begin practicing system design questions.

2. Work through system design interview questions

As you likely noticed in the common questions section, we recommend using a repeatable answer framework when answering system design interview questions. You can learn more about that framework here, but in the meantime, here is a summary:

Ask clarifying questions

First, spend about five minutes checking in with your interviewer about the functional and non-functional requirements of what you’re going to design. Ask about the system’s goals and how they will be measured. Be sure that you fully understand the question before moving forward.

Call out any assumptions you’re making that will influence your design approach. If applicable, ask about non-functional requirements such as availability, consistency, scalability, etc.

Design high-level

Start the high-level design by specifying one to two metrics (e.g. number of users added, products sold before vs after a feature launch, etc.). Then use these metrics to do some simple calculations in order to find the optimal usage pool of the system.

Once you’ve defined your metrics, map out only the most functional components of the system (e.g. front end, web server, database, etc.).

Finally, before getting into the more detailed aspects of your system, make some decisions on how you will design its database. Choose whether it will be a relational or a no-SQL database, as well as its metadata and table structure.

Drill down on your design

If you haven’t already, start mapping out the system on your whiteboard. Talk through your diagram so that your interviewer is able to follow along and ask questions when necessary.

Consider any bottlenecks that may arise when it comes to the system’s scalability, performance, or flexibility.

To finalize your design, play to your strengths by choosing a component you’re more familiar with and drilling down on it. If you’re not sure which component would be best to explore, ask your interviewer.

Bring it all together

Before wrapping up the round, take about five minutes to re-examine what you’ve designed. Does it meet the objectives you laid out with the interviewer at the beginning of the session? It is okay to change some components at this stage if you think it will improve the system, but you must explain to the interviewer what you are doing and why.

Apply this framework to practice questions like those we’ve included in this article. Use it on different types of questions in a variety of subjects, so that you learn how to adapt it to different situations and respond to unpredictable questions on the fly.

3. Practice answering example questions

You'll need to spend a good amount of time practicing answering questions on your own or watching mock interviews on YouTube.

Example system design questions - with solutions

Design TikTok (Solution)
Design Twitter (Solution)
Design Instagram (Solution)
Design a messaging app like Telegram (Solution)
Design Uber (Solution)
Design a parking lot (Solution)
Design Spotify (Solution)
Design a Distributed Message Queue (Solution)
Design a payment system (Solution)
Design a system to identify top 1K items (Solution)
Design a distributed cache (Solution)

4. Practice with someone else

Once you've done some individual practice, we would also strongly recommend that you practice solving system design questions with someone else interviewing you.

If you have friends or peers who can do mock interviews with you, that's an option worth trying. It’s free, but be warned, you may come up against the following problems:

It’s hard to know if the feedback you get is accurate
They’re unlikely to have insider knowledge of interviews at your target company
On peer platforms, people often waste your time by not showing up

For those reasons, many candidates skip peer mock interviews and go straight to mock interviews with an expert.

5. Practice with experienced system design interviewers

In our experience, practicing real interviews with experts who can give you company-specific feedback makes a huge difference.

Find a system design interview coach so you can:

Test yourself under real interview conditions
Get accurate feedback from a real expert
Build your confidence
Get company-specific insights
Save time by focusing your preparation

Landing a job at a big tech company often results in a $50,000 per year or more increase in total compensation. In our experience, three or four coaching sessions worth ~$500 make a significant difference in your ability to land the job. That’s an ROI of 100x!

Click here to book system design mock interviews with experienced system design interviewers.