Year-End Discount: 10% OFF 1-year and 20% OFF 2-year subscriptions!

Home/Blog/Top 14 System Design interview questions for software engineers

Top 14 System Design interview questions for software engineers

Nov 04, 2022 - 30 min read
Fahim ul Haq
editor-page-cover

Recently updated: This post was originally published Dec. 11, 2020. It was refreshed on Nov. 4, 2022.

Over my 10 years as a senior software engineer and interviewer at Microsoft and Facebook, I’ve worked with hundreds of applicants as they solve different system design problems.

Software developers tend to struggle with System Design interview questions because they are so open-ended and often require a kind of critical thinking not practiced in other coding interview challenges.

While SDI questions change over time, some have remained popular in interviews across various top companies.

Today, we’ll explore the top 14 most commonly asked system design interview questions, common problems you’ll have to address in each, and some tools to help you do that.

Here’s what we’ll cover today:


Get hands-on with modern system design today.

Try one of our 400+ courses and learning paths: Grokking Modern System Design Interview for Software Engineers and Managers.

Tips for any SDI Question

Start each problem by stating what you know: List all required features of the system, common problems you expect to encounter with this sort of system, and the traffic you expect the system to handle. The listing process lets the interviewer see your planning skills and correct any possible misunderstandings before you begin the solution.

Narrate any trade-offs: Every system design choice matters. At each decision point, list at least one positive and negative effect of that choice.

Ask your interviewer to clarify: Most system design questions are purposefully vague. Ask clarifying questions to show the interviewer how you’re viewing the question and your knowledge of the system’s needs.

  • State your assumptions before outlining the components

Discuss emerging technologies: Conclude each question with an overview of how and where the system could benefit from machine learning. This will demonstrate that you’re not just prepared for current solutions but future solutions as well.

Know your architectures: Most modern services are built upon a flexible, microservice architecture. Unlike the monolithic architectures of tech companies in the past, microservices allow smaller, agile teams to build independently from the larger system. Some older companies will have legacy systems, but microservices can function in parallel to legacy code and help refresh the company architecture as a whole.

For more information on how ML can improve your SDI performance, check out How Machine Learning gives you an edge in System Design.

widget

design messenger system design interview


1. Design a chat service like Facebook Messenger or WhatsApp

For this question, you’ll design a service that allows users to chat with each other over the internet. Conversations can be one-on-one or can be group chats with many members. Messages should only be accessible by those included in the conversation.


Requirements

Functional requirements

  • Online: Messages must be sent and received via the internet.
  • Multi-functional: Service must support one-on-one and group chats.
  • Archived: Messages should be stored for later viewing.
  • File agnostic: Users should be able to send pictures and videos as well as text messages.
  • Protected: Messages should be encrypted during transit.

Non-functional requirements

  • Consistency: Above all else, the system should be consistent; users should see the same chat log on all devices.
  • Availability: High availability is desirable, but not as crucial as consistency.
  • Low latency: The system should be extremely low latency, offering a real-time chatting experience.

High-level design

The high-level design for a messenger application is fairly simple. A user contacts a chat server and sends a message. The chat server relays the message to the user it was intended for, and then stores the message in a database. Once the message is delivered, the server notifies the sender that the message was successfully transmitted.


Common Problems

  • What happens if a message is sent without an internet connection? Is it sent when the connection is restored?
  • How will you encrypt and decrypt the message without increasing latency?
  • How do users receive notifications?
  • Are messages pulled from the device (server periodically prompts the devices if they’re waiting to send a message) or are pushed to the server (device prompts the server that it has a message to send)?

Tools to Consider

  • Split the database schema into multiple tables: user table (with the user ID and contacts), a chat table (with chat IDs and a list of participating user IDs), and message table (with past messages a reference to the chat ID).
  • Use WebSocket for bi-directional connections between device and server.
  • Use Push notifications to notify members even if they’re offline.

design uber system design interview


2. Design Uber

This question asks you to create a ride-sharing service that matches users with nearby drivers. Users can input a destination and transmit their current location and nearby drivers are notified within seconds.

The app then tracks a route between the driver and user’s current locations, then from the user’s location to the destination.


Requirements

Functional requirements:

  • Location tracking: The system should monitor the location of both drivers and riders at all times. Specific emphasis should be placed on updating drivers’ locations, since they are a constantly moving entity and the backbone of the service.
  • Show nearby drivers: The system should find and display nearby drivers to the rider.
  • Request a ride: When riders request a ride, the nearest drivers should be notified of the request.
  • Payments: The system should initiate the payment process when the trip begins.
  • ETA: The rider should be notified of the estimated time it will take for the driver to arrive.
  • Trip confirmation and updates: The driver should be able to confirm both pickup and dropoff to bookend the trip. Both driver and rider should be updated on ETA to the destination and current location over the course of the trip.

Non-functional requirements:

  • Availability: System downtime could result in the failure of a ride. If drivers are ever unable to locate riders or riders unable to contact drivers, the system will not work.
  • Reliability: While not as crucial as availability, reliability ensures that all users have an error-free experience.
  • Scalability: The system should be designed to accommodate growing numbers of drivers and riders.
  • Consistency: It is important that both drivers and riders have a consistent view of the system.

Plan to scale: It is of great interest to potential employers that you understand how to flexibly scale the infrastructure of a web application. Learn the basics of scalable systems.


High-level design

At its simplest, the system should accept ride requests from users and return driver and trip information. When a driver matches with a rider, the application should return the trip and rider information. The driver’s location should regularly be recorded and communicated to relevant users.


Common Problems

  • How can you keep latency low during busy periods?
  • How is the driver paired with the user? Iterating all drivers to find Euclidean distance would be inefficient.
  • What happens if the driver or user loses connection?
  • How do you store all cached location data?

Check out our guide to designing Uber’s backend for more information on Uber interview process.


Tools to Consider

  • Use the S2Geometry library to split locations into cells. Only calculate driver distance with drivers in the same cell as the user.
  • Use distributed storage to store locations of all users, location data will only be roughly 1Kb per user.
  • If location data halts, the device continues to report their previous location while waiting for reconnection.
  • Allow a buffer after prompting the closest driver to take a trip. If they refuse, move to the next driver.

design tinyurl system design interview


3. Design a URL shortening service like TinyURL or bit.ly

This question asks you to create a program that shortens long URLs like TinyURL or bit.ly. These programs take a long URL and generate a new and unique short URL. They can also take a shortened URL and return the original full-length URL.


Requirements

Functional requirements:

  • URL generation: The service should return a URL that is shorter than the original.
  • Storage: The original URL should be stored.
  • Redirection: The new, shortened link should redirect to the original URL.
  • Customization: The service should support custom shortened URLs.
  • Update and delete: Users should be able to update long URLs and delete short URLs from the system.

Non-functional requirements:

  • Availability: High availability is crucial, since downtime could result in link redirection failing.
  • Unpredictability: The short links should not be generated using a next-in-line pattern. It should be impossible to guess what URLs the system has produced or will produce next.
  • Readability: The shortened links should be easy to read and type.
  • Low latency and scalability: The system should be horizontally scalable and offer a smooth experience.

High-level design

A load balancer will serve as an intermediary between the clients and server, and a rate limiter should prevent flooding and exploitation. A sequencer will provide unique IDs for each URL that serve as the starting point for URL shortening. A base58 encoder transforms these numeric IDs into a more readable alphanumeric form. The original URLs are stored in a database, with recently used ones available in a cache.


Common Problems

  • What if two users input the same custom URL?
  • What if there are more users than expected?
  • How does the database regulate storage space?

Tools to Consider

  • Use hashing to link original and new URLs
  • Use REST API to load balance high traffic and handle front-end client communication
  • Use multithreading to handle multiple requests at once
  • Use NoSQL database to store original URLs (no relation between stored URLs)

Learn how to solve this problem in our step-by-step guide Design TinyURl and Instagram

design twitter system design interview


4. Design a mass social media service like Facebook, Twitter, or Instagram

For this question, you’ll design a social media service used by my hundred thousand users like Instagram. Users should be able to view a newsfeed with posts by followed users and suggest new content the user may like.

Interviewers often want to hear you discuss the newsfeed in depth.


Required Features

  • Robust newsfeed and recommendation system
  • Users can make public posts
  • Other users can comment or like posts
  • Must comfortably accommodate many users at once
  • System must be highly available

Common Problems

  • Famous users will have millions of followers, how are they handled vs standard users?
  • How does the system weight posts by age? Old posts are less likely to be viewed than new posts.
  • What’s the ratio of read and write focused nodes? Are there likely to be more read requests (users viewing posts) or write requests (users creating posts)?
  • How can you increase availability? How does the system update? What happens if a node fails?
  • How do you efficiently store posts and images?

Tools to Consider

  • Use rolling updates and replica nodes to maximize availability.
  • Use a trained machine learning algorithm to recommend posts.
  • Create a database schema that stores celebrities and users separately.
  • Use a social graph to further track following habits

Learn how to solve this problem with our step-by-step guide Design TinyURL and Instagram

design reddit system design interview


5. Design a social network and message board service like Quora, Reddit, or HackerNews

These social network sites operate on a forum-based system that allows users to post questions and links. For simplicity’s sake, we’ll focus more on designing Quora. It is unlikely that you’ll need to walk through the design of something like Reddit’s subreddit or karma system in an interview.


Requirements

Functional requirements:

  • Posting: Users should be able to share both questions and answers that can include images and videos if necessary.
  • Vote and comment: Users should apply upvotes, downvotes, and comments to questions and answers.
  • Search: Users should be able to retrieve questions that have already been asked.
  • Answer ranking: The most helpful answers should be positioned first in the thread.
  • Recommendation system: Users have a feed that includes topics they’ve expressed interest in. The system should facilitate user discovery as well.

Non-functional requirements:

  • Scalability: It should be easy to add both users and features to the system. Performance and usability should not be impacted as the system grows.
  • Consistency: For a question-and-answer system, it is imperative that all users see the same information. However, since different users have different interests, not all users need to view the same content as it is posted.
  • Availability and performance: The system should provide a smooth user experience and stay available in the event of many concurrent requests.

High-level design

Users contact an application server via web server to post questions, answers, and comments. Images and videos are placed in blob storage, and the question/answer data are stored in a MySQL database. A machine learning engine can be used to rank answers that it deems valuable. A recommendation system should tailor content to an individual user’s interests, and it should be available for both online and offline services.


Common problems

  • Does our product only need to work on the web?
  • How will the system determine related tags? How many posts from unfollowed tags are shown in the feed?
  • How are posts distributed across a network of servers?

Tools to consider

  • Map relational data with an SQL database (users have posts, posts have comments/likes, categories have related posts, etc.).
  • Use multithreading and a load balancer layer to help support higher traffic.
  • Break up the system via sharding. Consider sharding by category to store posts of the same tags in one machine.
  • Use machine learning and Natural Language Processing to map the relationships between tags.


Keep learning about System Design Interviews.

Get hands-on practice with all the top SDI questions. Educative’s courses are created by current developers to help you learn in half the time.

Grokking Modern System Design Interview for Software Engineers & Managers



6. Design Instagram

Above, we discussed how to design a newsfeed for an application like Instagram, but for this question we will dive deeper into how the system is designed.

Instagram is a social media platform that allows users to post pictures and short videos. Posts can be indexed and searched through hashtags and location-based geotags.


Requirements

Functional requirements:

  • Post: Users can create posts to upload pictures and videos.
  • Follow: Users should be able to follow and unfollow other users and hashtags.
  • Like: Users should like and comment on posts, and be notified when someone likes or comments on their post.
  • Search: The system should support searching for posts or users.

Non-functional requirements:

  • Scalability: The system should be highly scalable and be able to handle millions of accounts and posts.
  • Availability: High availability is important for user retention.
  • Durability and reliability: The system should not lose any posts or go down in the event of component failure.
  • Latency: Newsfeeds and searches should be returned quickly.

High-level design

From a high level, the system should support the upload and storage of multimedia content. Users should receive notifications for likes, follows, and comments. The core of the system is run by an API that performs the functional requirements and fulfills user requests. Since the data generated by the system is inherently relational, the design should include an SQL database that stores information as tables.


Common problems

  • Should the system push posts to followers upon upload, or should it pull posts from a database when a newsfeed is requested?
  • Replication is necessary to ensure that no data is lost, but it creates several complications. What does the system do with failed replica nodes? How does the system handle concurrent write requests?

Tools to consider

  • A wide-column database, like Cassandra, can house the relationships between users and posts.
  • Use data replication to ensure that no files are lost even in the event of partial failure.
  • A cache and a CDN can reduce the time it takes to fetch content.

design dropbox system design interview


7. Design a file sharing service like Dropbox, Google Drive, or Google Photos

For this question, you’ll create a synchronous, cross-platform storage system like Dropbox. Users can store files and photos and access them from other devices.


Requirements

Functional requirements:

  • Upload and download: Logged in users should be able to upload and download files from any device.
  • Share: Users should be able to share files with others.
  • Synchronization: All files should be synchronized across devices and users.

Non-functional requirements:

  • Consistency: Consistency is so integral to the system that it manifests itself as a functional requirement in the form of synchronization.
  • Scalability: The system should be able to support vast numbers of concurrent and monthly users. Google Drive has a staggering 1B users.
  • Large file size: The system should support large individual files, greater than 1 GB.
  • Low-latency: The system should offer fast read and write response times as well as efficient file uploads through multi-threading.

High-level design

The client side of the system should contain a service for splitting large files into smaller, more easily manageable chunks. These files are then sent to a processing queue that sends and receives requests to store metadata and ensure that files are synchronized between users and accounts. Files are stored in a cloud-based block storage platform, like Amazon S3. When a user wants to upload or download files they contact this storage service through a web server.


Common Problems

  • Where are the files stored?
  • How do you handle updates? Do you re-upload the entire file again?
  • Do small updates require a full file update?
  • How does the system handle two users updating a document at the same time?

Tools to Consider

  • Use chunking to split files into multiple sections. Updates only re-upload the section rather than the whole file.
  • Use cloud storage like Amazon S3 to handle the internal database.
  • Make the client constantly check with the server to ensure concurrent updates are applied.


8. Design Google Docs

A collaborative editing service should let users remotely and simultaneously make changes to text documents. The changes should be displayed in real time. Much like other cloud-based services, documents should be consistently available to any logged-in user on any machine. Your solution must be scalable to support thousands of concurrent users.


Requirements

Functional requirements:

  • Collaboration: Several users should be able to edit one document concurrently. Large numbers of users should be able to view documents at the same time.
  • Edit overlap: The system should be able to resolve conflicts that occur when users edit the same portion of a document at once.
  • Autocomplete and grammatical suggestions: The system should suggest frequently used words and phrases as well as corrections for minor grammatical errors.
  • History and view count: The view count and editing history of the document should be archived and readily viewable.

Non-functional requirements:

  • Consistency: As mentioned above, the system should remain consistent even in the event of conflicting edits.
  • Low latency: Users should experience low latency when typing and making edits.
  • Availability: A high uptime is necessary for users to access documents on demand.

High-level design

All user requests are sent through the API gateway. These requests can then be fulfilled uniquely depending on the desired result. The following are the core requests that the API should be capable of handling.

  • Conflicting collaborative edits: Requests are fulfilled via an operations queue that moderates conflicts. A time series database stores the data and compresses any multimedia submissions.
  • Suggestions: Suggestions should be performed as a typeahead service.
  • Import and export: Application servers should support the import, export, and file format conversion of documents.

Common Problems

  • How do you minimize latency when multiple users are distant from the server?
  • What techniques for conflict resolution are best for ensuring consistency?

Tools to Consider

  • A pub-sub (publish-subscribe) component, like Kafka, can queue asynchronous updates and notifications.
  • The suggestion function should be supported through a caching system like Redis.
  • Use WebSockets to expedite the transfer of small data in batches.

design youtube system design interview


9. Design YouTube

You are tasked to create an online video streaming service like YouTube. The service will store and transmit hundreds of petabytes of video data. It must also store statistics (views, likes, number of views, etc.) and allow for users to post comments.

Your solution must be scalable to support thousands of concurrent users.

Two for one: When it comes to designing a video streaming service, YouTube and Netflix are very similar. If you know how to design one, you know how to design the other.


Requirements

Functional requirements

  • Upload: Users should be able to upload videos over the internet.
  • Streaming: Playback should be uninterrupted and consistent.
  • Like, dislike, and comment: Users should be able to rate and comment on videos. The ratings and comments should be visible to other users.
  • Video metrics: Statistics related to the video’s performance should be cataloged and stored.
  • Search: Users should be able to search videos according to title and tags.

Non-functional requirements:

  • High availability: Availability ensures that users can consume long videos or multiple videos at a time without interruption.
  • Scalability: Video platforms must be capable of supporting large numbers of users and large amounts of video data.
  • Performance: To ensure a positive user experience, videos should be delivered in high resolution without buffering.
  • Multiple formats: Users should be able to upload videos in different file formats.

High-level design

Video uploads are first handled by a load balancer, and then delivered to an encoder. The encoder and transcoder split the video into different resolutions. These typically range from 140p to 1440p, but can go all the way up to 4k resolutions. All of these videos are stored in blob storage. Popular and recent uploads are held in a CDN. A content delivery network, or CDN, reduces latency when delivering video to users. In conjunction with colocation sites, the CDN stores and delivers requested data to users.


Common Problems

  • How will your service ensure smooth video streaming on various internet qualities?
  • How does your service respond to a sudden drop in streaming speed (buffering, reduced quality, etc.)?
  • How are the videos stored?

Tools to Consider

  • Implement cloud technology to store and transmit video data.
  • Use machine learning to suggest new video content.
  • Prevent stuttering for inconsistent connections with a delay. The user views data from a few moments ago rather than as it comes in.

design api rate limiter system design interview


10. Design an API Rate Limiter for sites like Firebase or Github

For this question, you’ll create an API rate limiter that caps the number of API calls a service can receive in a given time period to avoid an overload.

Interviewers can ask for this at various scales, from a single machine to an entire distributed network.


Requirements

Functional requirements:

  • Limit requests: A rate limiter’s core functionality is to cap the number of requests that can be sent to an API within a certain timeframe.
  • Configurable: The limit and time window should be adjustable.
  • System-wide coverage: It’s likely that users will be accessing the system across multiple servers. The rate limiter should count requests across all servers and return an error message to users if the limit is exceeded.

Non-functional requirements

  • Availability: Since rate limiters protect a larger system from being overburdened, they should be constantly running.
  • Lightweight: A rate limiter should not add any noticeable latencies to the user experience.

High-level design

A rate limiter should exist between a web server and an API server. When a client sends a request to the web server, the rate limiter is consulted. The rate limiter will determine if the request will be handled or throttled. If handled, the request is sent to the API server. If throttled, the request is denied.


Common Problems

  • How does your system measure requests per hour? If a user makes 10 requests at 1:20 then another 10 at 2:10, they’ve made 20 in the same one-hour window despite the hour change.
  • How would designing for a distributed system differ from a local system?

Tools to Consider

  • Use sliding time windows to avoid hourly resets.
  • Save a counter integer instead of the request itself to save space.


11. Design a web crawler

A web crawler is a bot that methodically searches the world wide web (WWW) for content. It begins from a pool of seed URLs. These bots acquire content through crawling and then store it for later retrieval.

To fully address this problem, you should design a web crawler and suggest seed URLs to get the process started.


Requirements

Functional requirements:

  • Crawling: The system should comb the web via a queue of seed URLs initially provided via an administrator.
  • Storage: The system should be able to extract and store content from the web into a blob store.
  • Scheduling: Web crawlers need to recrawl periodically to index new web pages.

Non-functional requirements:

  • Scalability: Web crawlers need to be capable of fetching hundreds of millions of web documents.
  • Extensibility: Most web pages are built with HTTP or HTTPS, but to ensure proper coverage the web crawler should support different network communication protocols.
  • Performance: The web crawler should be capable of self-throttling. The number of URLs crawled per second, and the throughput of the content, should be optimal.
  • User interface: The system should support the functionality of manually initiating recrawling.

High-level design

A web crawler begins by assigning a worker to a URL. Once the DNS is resolved, the worker sends the URL and IP address to an HTML fetcher to establish the connection. The URL and HTML content are extracted from the page and stored in the cache for processing. This content is then dedup tested to ensure that no duplicate content is transferred to blob storage. Once this cycle is complete for a single URL it moves on to the next address in the queue.


Common Problems

  • What functionalities need to be added to ensure that all formats (images and video) are extracted?
  • Real web crawlers have multiple workers handling separate URLs simultaneously. How does this change the queuing process?
  • How can you account for crawler traps?

Tools to Consider

  • A crawler should fetch a robots.txt file to determine how frequently to revisit the site as part of the Robots Exclusion Protocol.
  • Adjust the crawl speed based on an individual domain’s time to first byte (TTFB).
  • Use a domain level log to optimize the system for reverse URL indexing.

design yelp system design interview


12. Design a proximity server like Yelp or Nearby Places/Friends

For this question, you’ll design a proximity server that stores and reports the distance to places like restaurants. Users can search nearby places by distance or popularity. The database must store data for hundreds of millions businesses across the globe.


Requirements

Functional requirements:

  • Storage: The system should catalog data from hundreds of millions of global businesses in a database.
  • User accounts: There should be two different types of users: business owners and customers. Business owners should be able to update the information pertaining to their business entry, and customers should be able to leave ratings and reviews.
  • Search: Users should be able to search for a business based on their GPS location or the name of the business.

Non-functional requirements:

  • Scalability: The system should be scalable both up and down depending on the number of requests. Requests will likely follow the lunch and dinner waves every day.
  • Availability: High availability ensures a positive user experience and user retention.
  • Consistency: All customers and business owners should see the same reviews, images, and general information.
  • Performance: It is crucial that the system is able to search the area and return results quickly.

High-level design

When a user searches for business information, the request is sent first to read servers that then route it to QuadTree servers. These QuadTree servers return third-party map information and business information from a relational database and key-value store. A segment producer breaks the third-party map into smaller sections that business locations are added to. Users that leave reviews contact a write server that ultimately delivers the content to the relational database.

Data structures: A QuadTree is a tree-based data structure that partitions 2D space into quadrants.


Common Problems

  • How do you store lots of data and retrieve search results quickly?
  • How should the system handle different population densities? Rigid latitude/longitude grids will cause varied responsiveness based on density.
  • Can we optimize commonly searched locations?

Tools to Consider

  • Use a relational database to store the list of locations and related data.
  • Use caching to store data for the most popular locations.
  • Use sharding to split data by region.
  • Search locations within a certain dynamic grid. If there are more than 500 locations in a single cell, split the grid into 4 smaller cells. Repeat until you only have to search less than 500 locations.

design type ahead system design interview


13. Design a search engine related service like typeahead

Typeahead suggestions are more commonly referred to as an autocomplete feature. They are an essential part of search engines and sophisticated distributed search components.

This service will partially complete search queries and display five suggestions to complete the query. It should adapt to highly searched content in real time and suggest that to other users.

For example, “Seahawks win the Super Bowl” would be suggested within minutes of the event occurring.


Requirements

Functional requirements:

  • Autocomplete: The system should suggest the top N (usually five to ten) frequent and relevant terms to an individual user depending on the text in the search bar.
  • Autocorrect: Minor spelling mistakes should be corrected.

Non-functional requirements:

  • Low latency: The system should show a list of suggested queries in real time as a user types. Response time should be lower than 200ms.
  • Fault tolerance: Suggestions should be provided even in the event of component failure.
  • Scalability: The system should support an ever increasing number of users.

High-level design

When a user starts typing a query, each individual character is sent to an application server. A suggestion service gathers the top N suggestions from a distributed cache, or Redis, and returns the list to the user. An alternate service takes the query, analytically ranks it, and stores it in a NoSQL database.


Common Problems

  • How strongly do you weigh spelling mistake corrections?
  • How do you update selections without causing latency?
  • How do you determine the most likely completed query? Does it adapt to the user’s searches?
  • What happens if the user types very quickly? Do suggestions only appear after they’re done?

Tools to Consider

  • Use a natural language processing machine learning algorithm to anticipate the next characters.
  • Use Markov Chains to rank the probability of top queries.
  • Update ML algorithm hourly or daily rather than in real-time to reduce burden.


14. Design Google Maps

For this question you’ll design a service that can map the route between two locations. The system should map several optimal paths to a destination based on the mode of travel. Each route should display the total mileage and an estimated time of arrival.


Requirements

Functional requirements

  • Current location: The service should approximate a user’s current location on the map.
  • Fastest route: Given the departure location and the destination, the system should calculate and recommend the fastest route based on mode of transportation and traffic conditions.
  • Directions: Once the trip has begun, the system should deliver directions that guide the user on the optimal route.

Non-functional requirements:

  • Availability and scalability: The system should be highly available and scalable since it is useful to both individuals and enterprise applications like Uber and Lyft.
  • Low response time: There should be minimal wait time between entering a destination and receiving a route and ETA.
  • Accuracy: The predicted ETA should be close to the real-world travel time.

High-level design

When a user accesses the system, a load balancer mediates their request. The three main live data services are close to the user to ensure low latency:

  • A location finder
  • A route finder
  • A navigator An area-search component and a graph-processing service provide the functional backbone to route mapping via a shortest path algorithm.

Common Problems

  • How do you collect the world map data? What third-party source will you use?
  • How do you segment the map to avoid long loading times?
  • How do you ensure the accuracy of ETA calculations for high-traffic times of day?

Tools to Consider

  • A live stream of data from users can be used to inform ETA calculations on popular routes.
  • Use lazy loading to reduce initial load time of the application.
  • The system relies heavily on a shortest path algorithm. The most common of these is Dijkstra’s algorithm.


Get hands-on with modern system design today.

Try one of our 400+ courses and learning paths: Grokking Modern System Design Interview for Software Engineers and Managers.


Next steps for your interview prep

These questions should help you understand the kinds of problems you’re expected to solve for a system design interview. Answering questions like these is the most effective interview preparation strategy.

There are plenty more system design concepts to address during your preparation for a real-world FAANG interview. To give you hands-on practice with these solutions, Educative has created Grokking Modern System Design Interview for Engineers & Managers. This course will give you detailed walkthroughs on essential system design concepts and other example questions, written by current industry interviewers.

By the end, you’ll know exactly what modern interviewers are looking for and what clarifying questions to ask for each question. You’ll also have extensive practice in explaining your tradeoff decisions.

Happy learning!


Continue reading about System Design Interviews


WRITTEN BYFahim ul Haq

Join a community of more than 1.6 million readers. A free, bi-monthly email with a roundup of Educative's top articles and coding tips.