Today we’re going to go over the Google system design interview, with 45 confirmed Google system design interview questions, plus sample answers to the top 3 most common.
The information in this guide comes in part from an analysis of nearly 100 real system design interview reports collected from Google software engineer, engineering manager, and technical program manager candidates.
The first thing you’ll need to know: Google interviewers expect you to be VERY familiar with the company’s products ahead of time.
Let’s get started.
- Google system design interview basics
- Google system design interview questions
- Preparing for Google system design interviews
Google system design interviews are typically given to software engineer and TPM candidates at levels L5 and up. Each system design interview lasts 45 minutes and is focused on one complex problem like “design YouTube.” Google typically gives 1-3 system design interviews, depending on the level of the candidate.
Google has a reputation for having some of the highest standards when it comes to technical capabilities, which makes their coding and system design rounds especially tricky.
Some candidates have even reported receiving a system design question that proved to be intentionally unsolvable—however, it should be noted that this is rarely the case.
Many Google interviewers also prefer that candidates refrain from using specific products (e.g. certain databases, load balancers, etc.), instead requiring candidates to build from scratch. This is because interviewers want to be sure that candidates know how these components work, rather than resorting to a product that takes care of certain aspects like sharding (even if it’s what you may ultimately use when you’re on the job).
Be sure that you’re up to date on the latest Google products and releases, as well as their legacy products, as you’ll most likely be asked system design questions that relate to them. Here are some resources that can help:
- Google's mission statement (by Google)
- Google's values (by Google)
- Google strategy teardown (by CBS Insights)
- Google's company blog (by Google)
Finally, your interviews may take place virtually, meaning you’ll have to map out your design in Google Docs or using Google Draw. Test these tools beforehand so that you’re not taken off guard in the interview setting.
Now that you’ve got an idea of how system design interviews work at Google, let’s get into the complete list of system design questions that have been asked in real Google interviews, according to data from Glassdoor.
Out of all the Google system design interview questions that we collected from Glassdoor, these first three questions were repeated multiple times across different roles. Since Google clearly favors these questions, we’re putting a spotlight on them, with suggestions and sample answers for each.
Below each question, you’ll find a repeatable framework that you can use to answer any system design interview question. For a full explanation of the framework, consult our system design question guide.
1. Design Google Maps
One of the most common Google system design interview questions, “design Google Maps” requires candidates to tackle an incredibly complex task—building a complete navigation system — in 60 minutes or less.
Below, take a look at some points of consideration and questions to keep in mind when working through this system.
Sample answer: Design Google Maps
Ask clarifying questions
- What are the functional and non-functional requirements? (e.g. route planning, time and distance estimations, identifying roads, availability, accuracy, etc.)
- How many monthly average users are there? How frequently do they access the app?
- How will your system designate the fastest route from point A to point B? (Dijkstra’s algorithm, Bellman Ford Algorithm, Floyd-Warshall Algorithm, etc.)
- How will you store the above information?
- How will you optimize the system to only take into account relevant roads instead of all roads in the world or country?
Drill down on your design
- How will you map out the architecture, and what components will you use to handle requests? Which components will you build yourself versus using specific tech (Cassandra, Hadoop, WebSocket managers, etc).
- Can you dive deeper on a specific aspect? (traffic predictions, estimated time of arrival, etc.)
Bring it all together
- How can you improve what you’ve built? Are there bottlenecks you could resolve or aspects you could optimize?
For the full breakdown of an answer to this question, take a look at the video below from codeKarle.
2. Design autocomplete for a search engine
This question came up most frequently in software engineer and engineering manager interviews. Take a look at the framework below for an approach to this question, followed by the video version of a full sample answer.
Sample answer: Design autocomplete for a search engine
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?
- 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.
3. 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.
Sample answer: Design a web cache
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?
- 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.
More Google system design interview questions
Now, let’s get into the complete list of system design interview questions asked in interviews for different roles at Google.
Keep in mind that, in most cases, your interviewer will adapt the question to your background. For instance, if you've worked on an API product they're more likely to ask you to design an API. But that won't always be the case, so practice with the questions below to be ready to design any type of product or system at a high level.
We’ve divided the questions by role: software engineer, engineering manager, and technical program manager.
Note that for each role, interviewers ask similar questions to test different skills. For example, engineering managers will be expected to give more in-depth answers than software engineers, including a discussion of how the system would play into the larger business context of the company. TPMs must be able to discuss the merits of different architectures in order to work with engineers.
Test out your skills using the questions below.
Google system design interview questions (for software engineers)
- Design a word predictor for a search engine.
- Design an implementation for a system like Git.
- Design a shuffle system for a music player with k iteration of cooldown, given a list of songs.
- Design a T-shirt machine.
- Design the front page for a news source that aggregates sources across newspapers.
- Design an API for an elevator.
- Design a system for a robot to learn the optimal layout of a room and traverse it completely.
- Design a large system for virtual machines addresses in physical machines.
- Design a tile-matching game (similar to Candy Crush). It shouldn’t have any matching 3 symbols on a fresh board, and there should be at least one possible move.
- How would you distribute YouTube servers?
- Design Google Drive.
- Design a recipe finder that generates recipes when given raw ingredients.
- Design a service that provides services to applications using an edge network.
- Design a ticketing platform.
- Design a video game.
- Design an online booking system for a restaurant.
- Create a cache where values get invalidated based on a TTL (time to live).
- Implement a swipe to text keyboard.
- Design a search engine.
- Design Twitter.
- Design a data center on the moon.
- Design a house-cleaning robot.
- Design Google Calendar.
- Design a social network.
- Design a system that protects data exchanged between end-station and the server. Provide solutions for data privacy, authentication, data collection, etc.
- Design a task-scheduling system.
- Design an elevator.
Google system design interview questions (for engineering managers)
- Design a system to view the latest stock prices from around the world.
- Design a photo sharing website, on which users can upload, edit, and download photos, browse web and mobile UI with thumbnails of users’ photos.
- Design a system that displays advertisements next to search results, based on keywords.
- Design a scoring system for Google services.
- Design a ticket booking system.
- Design a database.
- Design an in-memory cache for web pages.
- Design a boggle solver.
- Design a distributed id generation system.
Google system design interview questions (for technical program managers)
- Design Google Maps.
- Design Street View.
- Design YouTube.
- Design a key pair system which can handle 3,000 keys per second.
- How will you move 100 petabytes of data from the East Coast to the West Coast?
- How will you build a global system to upgrade software on a fleet of machines?
- Design a web cache.
- How would you deploy a solution for cloud computing to build in redundancy for the compute cluster?
- Design the server infrastructure for GMail.
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, which is why we recommend the four steps below.
For extra tips and resources, take a look at our system design interview prep guide and our list of 19 system design interview tips from ex-interviewers.
1. Learn the interview process
Of course, your system design interviews at Google will be part of a larger interview process. For help understanding the overall interview process and practice questions for every type of question you’ll be asked, use one of the guides below.
- Google software engineer interview guide
- Google engineering manager interview guide
- Google TPM interview guide
Now, let’s dig deeper into system design interview prep.
2. 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, which can eliminate 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.
3. Work through system design interview questions
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:
Step 1: 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.
Step 2: 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.
Step 3: Drill down on your design
If you haven’t already, start mapping out the system on your whiteboard. Speak 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.
Step 4: 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 provided above. 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.
4. Practice with mock interviews
The first step is always to practice by yourself, as we touched on above. Once you’ve got the framework down, start interviewing yourself out loud as you practice. Play both the role of the interviewer and the candidate, asking and answering questions. This will help you develop your communication skills and your process for breaking down problems.
Practice with peers
Once you've done some individual practice, we would also strongly recommend that you practice solving system design questions with a peer interviewing you.
A great place to start is to practice with friends or family if you can. This can help you get some preliminary feedback on your approach, which will be especially helpful if your partner is familiar with system design interviews.
If you don't have anyone in your network who can interview you, then you might want to check out our system design mock interview peer group, where you can set up practice interviews with other candidates.
Practice with ex-interviewers
Practicing with peers can be a great help, and it's usually free. But at some point, you'll start noticing that the feedback you are getting from peers isn't helping you that much anymore. Once you reach that stage, we recommend practicing with ex-interviewers from top tech companies.
If you know someone who has experience running interviews at Google, then that's fantastic. But for most of us, it's tough to find the right connections to make this happen.Here's the good news. We've already made the connections for you. We’ve created a coaching service where you can practice system design interviews 1-on-1 with ex-interviewers from Google. Learn more and start scheduling sessions today.