System Design Interview Questions and Answers for 2026

Messages are routed from a sender to the recipient, through a message queue. The main purpose of a message queue is to decouple the communication between these parts so that they can operate independently and asynchronously. It operates under the FIFO (first in, first out) principle.  

In a message queue system, there are three main components: 

1. Producers: These are the components that send messages to the queue. 
2. Queue: This is the message queue itself, which stores the messages until they are retrieved by the consumers. 
3. Consumers: These are the components that retrieve messages from the queue and process them. 

Message queues can also be used to provide reliability and fault tolerance to a system. If a consumer fails to process a message, the message can be returned to the queue for processing by another consumer. This allows the system to continue operating even if one or more components fail.  

There are many different types of message queue systems available, including Apache Kafka, RabbitMQ, and ActiveMQ. Each has its own set of features and capabilities and can be used in different types of systems depending on the specific requirements. 

Apache Kafka: Apache Kafka is a distributed, real-time message queue system that is widely used for building scalable, high-throughput, and fault-tolerant architectures for data processing, streaming and messaging. Kafka is a publish-subscribe messaging system that allows producers to send messages to topics and consumers to read from those topics. Topics are partitioned and replicated across the cluster, allowing for high scalability and availability. One of the key features of Kafka is its ability to handle large amounts of data with low latency. 

A database schema is a structure that defines the organization and relationships of data in a database. It specifies the data types, the attributes of each data element, and the relationships between different data elements.

In system design, the database schema is an important consideration because it determines how the data will be stored and accessed. It needs to be carefully planned and designed to ensure that the database is efficient, scalable, and easy to use.

There are two main types of database schema:

1. Physical Schema: This defines how the data is stored on disk, including the data types, sizes, and locations of the data elements.
2. Logical Schema: This defines the logical structure of the data, including the data types, attributes, and relationships between different data elements.

The physical schema is usually implemented by the database management system (DBMS), while the logical schema is defined by the database designer. The logical schema is used to create the physical schema, and it is also used by users and applications to interact with the database.

CQRS (Command Query Responsibility Segregation) is a design pattern that is used to separate the responsibilities of reading and writing data in a system. In a CQRS system, the write side of the system is responsible for storing data, while the read side is responsible for retrieving and displaying data. These two sides are usually implemented as separate components, and they can use different data models and storage mechanisms.

2PC (Two-Phase Commit) is a protocol that is used to coordinate transactions across multiple systems in a distributed environment. It has 2 phases i.e. the Voting/Prepare/Commit request phase and the commit phase where based on the voting, the system decides to commit or abort the transaction.

It is designed to ensure that all systems participating in a transaction either commit or roll back the changes they have made as a group, to ensure that the overall transaction is either completed or canceled.

In a 2PC system, there is a central coordinator that coordinates the transaction, and multiple participants that participate in the transaction.

Consistent hashing is a technique that is used to distribute keys or data elements across a distributed system in a way that minimizes the number of keys that need to be moved when the number of nodes in the system changes. It is commonly used in distributed systems to distribute data and workloads evenly across multiple servers or components and to ensure that the system remains balanced and efficient even when nodes are added or removed. 

A Bloom filter is a probabilistic data structure that is used to test whether an element is a member of a set. It is a space-efficient data structure that allows for fast membership tests, but it also has a certain probability of false positives, meaning that it may occasionally indicate that an element is a member of the set when it is not. If all of the positions are set to 1, the element is considered to be a member of the set. However, if any of the positions are set to 0, the element is considered to not be a member of the set.

1. Sensor Selection: The first step would be to select the appropriate sensors for the task. Depending on the requirements of the system, the robot could use a combination of sensors such as LIDAR, ultrasound, stereo vision, or infrared sensors to gather data about its surroundings. 
2. Data Collection and Processing: The robot would then use its sensors to collect data about the layout of the room and its surroundings. This data would be processed by the robot's onboard computer to create a map of the room and identify the location of obstacles and landmarks. 
3. Path Planning: The robot would then use algorithms to plan a path through the room, avoiding obstacles and navigating to its desired destination. This could involve the use of techniques such as A* search or gradient descent. 
4. Motion Control: Once a path has been planned, the robot would need to use its motors and control systems to execute the planned path and navigate through the room. This could involve the use of feedback control loops and PID controllers to ensure that the robot follows the planned path accurately. 

The steps to design any URL shortening service is as follows -

• Requirements: Requirements can be categorized into three categories:
  • Functional Requirements: The shortened URL must be unique. Users must be redirected to the original URL once they hit the short URL. The URL link should expire after a certain time period.
  • Non-Functional Requirements: The system ought to have high availability with minimum latency. This is necessary because all URL redirections will start to fail if our service is unavailable. 
  •  Additional Requirements: The misuse of services must be avoided, and other APIs must be able to use the shortened URL. 
• Constraints and Estimations: To keep the scalable service following must be considered:
  • Write per second: 100 million/ 24/2600 = 1160. 
  • Read: Assuming the read-to-write ratio would be 10:1 -> 1160*10 =11600
  • Storage: Considering we store each link for 10 years and expect 100M new requests per month, then
    100 million * 10 years* 365 = 12 billion
    Further, assuming each record stored will be approx. 300 bytes then
    12 billion * 300 bytes = 3.6TB
• Database: A key-value store, such as Redis or a document database like MongoDB, is used to store the mapping between short URLs and long URLs. The database should be optimized for high read and write performance, as it will be the primary source of truth for the service. 
• API: Two primary APIs would be required. The first will be POST to generate a new short URL, and the second will be GET for redirecting the URL.
  API Key, Original URL, and Expiration(Optional) are the parameters that form the API. 
• URL Shortening logic: Encode the original URL using Base62 consisting of upper case A-Z, lower case a-z and numbers 0-9. Number of URLs= 62^N, N is the number of characters in the generated URL.  
  Another way is to use the hash function MD5 message-digest algorithm, which generates a 128-bit hash value. 
• Caching: To improve performance, the service can use a caching layer, such as Memcached, to store frequently accessed URL mappings in memory. This can help reduce the load on the database and speed up the retrieval of long URLs. 
• Load Balancing: The service should be designed to handle a high volume of traffic and be scalable to accommodate future growth. This can be achieved by using a load balancer, such as HAProxy or NGINX, to distribute incoming requests across multiple instances of the API. 
• Monitoring and Logging: The service should be monitored for performance and availability, and logs should be generated and stored for debugging purposes. This can be achieved using tools such as New Relic, Datadog, or ELK (Elasticsearch, Logstash, and Kibana). 
• Security: Security should be a top priority when designing the URL shortening service. This might involve implementing measures such as SSL/TLS encryption, rate limiting, and input validation to prevent attacks such as SQL injection, XSS, and DDoS. 

A common System design interview question, don't miss this one.

One of the most frequently posed System design interview questions, be ready for it.  

Start by establishing a design scope by determining the major features to be included as below:

1. One-on-one and Group chat  
2. Offline/Online/Typing Status of Users
3. Sharing of media files

Next, break down the application into components as below:

1. Client: Here client refers to the mobile app or a web application. Clients do not directly interact with each other. Instead, they connect to a chat server. 
2. Server: It houses all the programs, databases, and frameworks required for the chat application to function. It will receive the message, identify the right recipient, queue the message, and direct the message to the identified recipient.
3. WebSocket Server: A WebSocket is a constant link between the client and the server that offers a two-way communication channel. This means that data can be sent from the server to the client without a request being made first. Real-time communication is the ideal scenario for WebSockets.
4. Storage of Messages/Media: Use a NoSQL database for the messages and a dependable and strong relational database for generic data like profile settings. NoSQL databases like Cassandra are ideal for storing messages because they enable easier horizontal scaling and low-latency data access.
5. Polling: It is defined as a technique where the client periodically queries the server to see if there are any new messages. Polling could be expensive, depending on how frequently it is done.
   To combat this, we can use long polling. When a client uses long polling, the connection is kept open until either new messages are actually available or a timeout threshold is reached. The process is restarted as soon as the client receives new messages by making a new request to the server.

Common frontend (client) languages are Javascript, Java, Swift and common backend (server) languages are Erlang, Node.js, PHP, Scala, Java, and many more.

Deciding on the application framework is equally vital. We have some chat protocols like Extensible Messaging and Presence Protocol (XMPP) used by WhatsApp and Message Queue Telemetry Transport (MQTT) which is relatively new. 

The Web crawler is a search engine-related tool, similar to Google and DuckDuckGo, that indexes website material online so that it may be made available for every result. 

Which features are some of the requirements? 

• Create and implement a Scalable service for retrieving millions of online documents and gathering data from the whole web. 
• Every search query requires the retrieval of new data. 

What are some typical issues that arise? 

• How should updates be handled when people type quickly? 
• How should dynamically changing web pages be prioritized? 

The potential pointers: 

• Consider using URL Frontier Architecture to put this system into place. 
• Learn the differences between scraping and crawling. 

A staple in System design interview questions, be prepared to answer this one.  

To design a message board platform like Quora, you can follow these steps: 

• Define requirements: Start by defining the key features of your platform. Some of the core features of a message board platform like Quora include the ability to ask and answer questions, the ability to vote on questions and answers, the ability to comment on questions and answers, the ability to follow users, and the ability to search for questions and answers. 
• Architecture: Architecture refers to the high-level structure and organization of a software system. In the case of a message board platform like Quora, the architecture would involve the components and services.
•  Front-end: The front-end would be responsible for presenting the platform to users and handling user interactions. It would likely be built using a JavaScript framework such as React or Angular. 
• API: The API would serve as the interface between the front-end and back-end, allowing the front-end to request data from the back-end and the back-end to receive and process requests from the front-end. 
• Back-end: The back-end would be responsible for storing and managing data, processing user requests, and returning the results to the front-end. It would likely consist of a set of microservices, each responsible for a specific task, such as storing questions and answers, managing votes, or handling comments.
• Database: The database would store all the data for the platform, such as questions, answers, votes, comments, and user information. 
• Data Modeling: you would need to model the following data entities:
  • Questions: The questions asked by users on the platform.
  • Answers: The answers provided by users to questions.
  • Users: The users who ask questions and provide answers.
  • Votes: The votes cast by users on questions and answers.Comments: The comments made by users on questions and answers.
  • Followers: The relationships between users, allowing users to follow each other. 
• API Design: The API design should consider the following:
  The API should provide a set of endpoints for the front-end to access, such as endpoints for creating questions, answering questions, and voting on questions and answers.

API should define the format of the requests and responses between the front-end and back-end. This may involve using a standardized format such as JSON.
 
The API must include mechanisms for authenticating users, such as OAuth, to ensure that only authorized users can access the platform's data.
 
The API should include error handling to ensure that the front-end can handle error responses from the back-end in a predictable and user-friendly manner.

• Front-end Development: Develop the front-end of your platform using a JavaScript framework such as React or Angular. The front-end should provide a user-friendly interface for users to ask questions, answer questions, vote on questions and answers, comment on questions and answers, follow users, and search for questions and answers. 
• Security: Some of the security measures that should be considered for a message board platform include:
  Authentication: Implementing robust user authentication mechanisms, such as OAuth, to ensure that only authorized users can access the platform's data.
• Authorization: Implementing role-based access control mechanisms to ensure that users can only perform actions that they are authorized to perform. 
• Encryption: Encrypting sensitive data, such as passwords, to protect it from unauthorized access.
• Input validation: Validating user input to prevent malicious attacks, such as SQL injection or cross-site scripting (XSS) attacks.
• Scalability: Make sure your platform is scalable to accommodate a growing user base. Consider using cloud-based infrastructure, such as AWS or Google Cloud, to easily scale your platform as needed. 
• Deployment: Deploy your platform to a production environment, making sure to monitor the platform for performance and stability. 

This is a high-level overview of the steps involved in designing a message board platform like Quora. In practice, the design process can be much more complex and will likely involve many more details and considerations.

To design a social media platform like Twitter, you would need to consider the following components: 

1. Front-end: The front-end would be responsible for presenting the platform to users and handling user interactions. It would likely be built using a JavaScript framework such as React or Angular. 
2. API: The API would serve as the interface between the front-end and back-end, allowing the front-end to request data from the back-end and the back-end to receive and process requests from the front-end. 
3. Back-end: The back-end would be responsible for storing and managing data, processing user requests, and returning the results to the front-end. It would likely consist of a set of microservices, each responsible for a specific task, such as storing tweets, managing user accounts, and handling real-time updates. 
4. Database: The database would store all the data for the platform, such as tweets, user information, and relationships between users. 
5. Real-time Updates: The platform would need to support real-time updates to provide a responsive and dynamic experience for users. This could be achieved using a technology such as WebSockets or Server-Sent Events. 
6. Search: The platform would need to include a search functionality to allow users to search for tweets and users. 
7. Notification: The platform would need to include a notification system to alert users of new mentions, replies, and other events. 
8. Analytics: The platform would need to include analytics functionality to provide insights into user behavior and engagement. 

In terms of data modeling, you would need to model the following data entities: 

1. Tweets: The tweets posted by users. 
2. Users: The users who post tweets and follow other users. 
3. Relationships: The relationships between users, allowing users to follow each other. 
4. Mentions: The mentions of other users in tweets. 
5. Hashtags: The hashtags used in tweets. 

Real-time updates is an important feature of many social media platforms, including Twitter, as it enables users to receive updates in near real-time as events occur. To implement real-time updates, you would need to consider the following components: 

• WebSockets or Server-Sent Events: To provide real-time updates, you would need to use a technology that enables bi-directional communication between the client and server. Two popular technologies for this are WebSockets and Server-Sent Events. 
• Notification Service: The notification service would handle the real-time updates and notify the front-end whenever new events occur, such as a new tweet or a new mention. This service would likely be built as a microservice and would use WebSockets or Server-Sent Events to communicate with the front-end. 
• Event Storage: The event storage would store events such as tweets and mentions, allowing the notification service to retrieve the latest events and notify the front-end. This could be implemented using a database or a distributed event store. 
• Event Processing: The event processing component would handle the creation of new events, such as when a user posts a tweet or receives a mention. It would store the new events in the event storage and notify the notification service to update the front-end. 

The search functionality is a key component of many social media platforms, including Twitter, as it allows users to find and discover content. To implement search in your platform, you would need to consider the following components: 

• Indexing Service: The indexing service would be responsible for indexing the data in your platform, such as tweets and user information so that it can be searched efficiently. The indexing service could use technology such as Elasticsearch or Apache Solr, which are popular open-source search engines. 
• Query Service: The query service would handle user search requests and return the results to the front-end. It would use the indexed data to perform the search and return the results in a format that can be easily consumed by the front-end. 
• Data Storage: The data storage component would store all the data in your platform, such as tweets and user information. The indexing service would use this data to create the indexed data that is used by the query service. 

Some popular algorithms for search include: 

• TF-IDF (Term Frequency-Inverse Document Frequency): 
• PageRank 
• BM25 (Best Matching 25) 

The biggest challenge to combat in this design would be demand vs. supply hence we would need two services for supply (of cabs) and demand (of riders). We will go with Uber’s example to understand the design and architecture.

1. The supply service uses latitude and longitude information to track the taxis (geolocation). The load balancer receives location updates from all of the active taxis, say, once every five seconds, via a web application firewall.
2. The demand service is received via web sockets. It begins tracking the rider's GPS location as soon as the request is made. The demand service also receives other requests, such as the kind of car, how many seats, etc., in addition to the rider's location.
3. Uber's architecture includes a dispatch system (Dispatch optimization/DISCO) to balance supply and demand. Riders and drivers are located by DISCO using a more precise Google S2 Library that divides the location's map into tiny cells rather than just using latitude and longitude. You can have 1km square cells across the map, based on your needs. It is easier to store cell data in the distributed system and access it using the ID because each of these cells is given a distinct ID. Consistent hashing can be used to store cell data.
4. Uber uses its four sets of map regions to determine the resources and map quality of a region. The grades for these sub-regions are A(Urban), B(Rural and SubUrban), AB(Union of Urban and Rural), and C(Highways).
5. To calculate ETA, the shortest route on a map with road networks can be discovered using Dijkstra's algorithm, which is the most straightforward method. More sophisticated AI algorithms may also be used to produce the most accurate time estimates because the shortest path (in terms of distance) isn't always the quickest path (heavy traffic may affect the arrival time).
6. Initially, Uber stored profile-related data and other items in an RDBMS PostgreSQL database. They had to change to a more scalable option though as more drivers and riders joined the app and the service spread to more cities. Uber currently uses a MySQL-based, schema-less NoSQL database. 

An API rate limiter is a system that is designed to limit the rate at which an API can be accessed by clients. This can be useful in situations where it is necessary to prevent excessive use of the API, such as to protect against denial of service attacks or to ensure fair usage by all clients. 

There are several factors to consider when designing an API rate limiter: 

1. Limits: The first step in designing an API rate limiter is to determine the appropriate limits for the API. This may involve considering factors such as the expected volume of traffic, the needs of the clients, and the resources of the server. The limits may be set on a per-user or per-application basis, or they may be based on other criteria such as IP address or location. 
2. Algorithm: Multiple algorithms can be used to implement an API rate limiter, such as a fixed window algorithm or a sliding window algorithm. It is important to choose an algorithm that is appropriate for the needs of the API and that can scale to handle a large number of requests. 
3. Storage: The API rate limiter will need to store information about the usage of the API, such as the number of requests made and the time of the last request. It is important to choose a storage solution that is efficient and scalable. 
4. Implementation: The API rate limiter will need to be implemented as part of the API server, and it will need to be integrated with the authentication and authorization mechanisms of the API. It is important to ensure that the rate limiter is reliable and performs well under different workloads. 

Search typeahead is a feature that suggests search terms or results as a user types in a search query. It is commonly used in search engines and other types of search interfaces to help users find relevant information more quickly and easily. 

A search typeahead is a feature commonly found in search boxes that provides suggestions to the user as they type. It is designed to help users find what they are looking for more quickly and efficiently. The goal of a search typeahead is to provide relevant and accurate suggestions in real-time as the user types. 

To design a search typeahead, we would typically follow these steps: 

1. Determine the Data Source: The first step in designing a search typeahead is to determine where the suggestions will come from. This could be a database of keywords, a list of products, or a combination of both. 
2. Implement the Suggestion Engine: The suggestion engine is responsible for returning the relevant suggestions based on the user's input. This could be done using a trie data structure, a simple search algorithm, or a more complex machine learning model. 
3. Implement User Interface: The user interface should display the suggestions to the user in a clear and concise manner. The suggestions should be easily distinguishable and the selected suggestion should be highlighted. 
4. Optimize for Performance: Performance is critical for a search typeahead, as it needs to provide suggestions in real-time as the user types. We should consider using caching, pre-computing results, and minimizing the number of database queries to optimize performance. 
5. Consider Personalization: To provide a better user experience, we may want to consider personalizing the suggestions based on the user's previous search history or other relevant data. 
6. Implement Analytics: To improve search typeahead over time, it is important to gather data on how it is being used and make changes as necessary. We can implement analytics to track usage patterns, user behavior, and the success rate of the suggestions. 

There are several algorithms and data structures that can be used to implement the suggestion engine, including: 

• Trie Data Structure: A trie (also known as a prefix tree) is a tree-like data structure that is optimized for searching prefixes.  
• Simple Search Algorithms: Simple search algorithms such as linear search or binary search can be used to search through a list of words to find relevant suggestions.
• Machine Learning Models: Machine learning models, such as a neural network or a decision tree, can be used to predict the most relevant suggestions based on the user's input.
• Hybrid Approach: A hybrid approach can be used to combine the strengths of multiple algorithms. For example, you could use a trie to quickly find suggestions that start with the user's input, and then use a machine learning model to rank the suggestions based on relevance. 

The choice of algorithm for your suggestion engine will depend on the specific requirements of your platform, including the size and structure of your data, the desired performance, and the complexity of the search problem. We may need to evaluate multiple algorithms and perform performance testing to determine the best choice for your specific use case. 

A well-designed search typeahead can greatly improve the user experience and make it easier for users to find what they are looking for. It is important to consider the specific requirements of the platform and evaluate different options to determine the best design for our specific use case. 

1. Create a game server that listens for incoming connections from clients. 
2. When a client connects to the server, the server creates a new game instance and adds the client to the game as a player. 
3. The server maintains a list of active games and routes messages from clients to the appropriate game instance. 
4. The game instance handles the game logic, including updating the game board, checking for wins or draws, and sending updates to the clients. 
5. The client UI displays the game board and allows the player to make their moves. The client sends move requests to the server, which are then passed on to the game instance. The client also receives updates from the server and updates the UI accordingly. 
6. The server and clients communicate using a network protocol, such as HTTP or WebSockets. 

This is just one possible design for a tic-tac-toe game, and there are many other ways to implement it. For example, we can use a client-server architecture, or we could implement the game as a standalone application. Also, additional features could be added, such as support for multiple players, leaderboards, or different game modes. 

1. The parking lot system has a server that manages the parking spaces and handles requests from clients. 
2. Clients can be drivers looking for a parking space, or staff managing the parking lot. Clients connect to the server through a user interface, such as a website or a mobile app. 
3. The server maintains a database of parking spaces, vehicles, and parking tickets. It also stores information about parking rates and policies. 
4. When a driver arrives at the parking lot and wants to park their vehicle, they use the client UI to request a parking space. The server responds by reserving an available space and issuing a parking ticket to the driver. 
5. When the driver is ready to leave, they use the client UI to request their vehicle. The server retrieves the vehicle from the parking space and calculates the parking fee based on the ticket's time stamp and the current rate. The driver can then pay the fee through the client UI. 
6. Staff can use the client UI to view the status of the parking lot (such as the number of available spaces), and to perform tasks such as issuing tickets for parked vehicles that violate the parking rules. 

1. ATM is connected to a bank's server through a network connection. The server stores information about customer accounts, as well as the transactions that have been made using the ATM. 
2. The ATM has a processor that runs the software and performs the operations required to fulfill requests from the user. It also communicates with the server to perform operations on the user's account. 
3. The ATM has a user interface that consists of a display screen, a keypad for entering commands and data, and a card reader for reading bank cards. 
4. When a user inserts their bank card into the ATM, the card reader reads the card and sends the card's information to the processor. The processor uses this information to identify the user's account and retrieves the account information from the server. 
5. The user can then enter their PIN (personal identification number) using the keypad to authenticate themselves. If the PIN is correct, the processor allows the user to access their account. 
6. The user can then use ATM to perform various operations, such as checking their account balance, withdrawing cash, or transferring money to another account. The processor communicates with the server to perform these operations and updates the user's account information as necessary. 
7. The ATM has a printer for printing receipts for transactions, and a cash dispenser for dispensing cash to the user. 

• Start by gathering data on the available aircraft and their capabilities (such as capacity, range, and fuel efficiency), as well as data on the routes and destinations that the airline serves. Gather data on the passengers, including their personal and contact information, ticket information, and any special requests or needs (such as wheelchair assistance or special meals). 
• Next, design a system for storing and managing the aircraft, route, and passenger data. This could involve using a database or a distributed storage system to store the data, as well as implementing processes for adding, updating, and deleting data as needed. 
• Design a system for scheduling flights that take into account the availability of aircraft, the demand for different routes, and any constraints or rules (such as the need for certain types of aircraft or the requirement for a certain number of flights per week). This could involve using a scheduling algorithm that optimizes the use of aircraft and minimizes costs, or it could involve implementing a calendar-based system where flights can be manually scheduled by the staff. 
• To enable passengers to book flights online, design a system for allowing passengers to browse the available flights and select a flight that works for them. This could involve integrating the scheduling system with a website or a mobile app that allows passengers to view the available flights and select one to book. 
• Furthermore, design a system for managing and tracking the flights, including the ability to communicate with passengers and provide updates on the status of their flight, as well as the ability to track and report on the performance of the airline. Also design a system for handling canceled or delayed flights, including the ability to rebook passengers on alternative flights or provide compensation as needed. 

There are many different approaches to designing a recommendation system, and the specific design will depend on the goals of the system and the type of data it has available. Below are some general steps that I will follow to design a recommendation system: 

1. Define the Problem: Identify the goals of the recommendation system clearly and the type of recommendations it should make (such as products, movies, or articles). 
2. Collect Data: Gather data on the items that the recommendation system will recommend, as well as data on the users who will receive the recommendations. This data may include explicit ratings or preferences (such as "likes" or "favorites"), or it may be derived from user behavior (such as clickstream data or purchase history). 
3. Preprocess the Data: Clean and transform the data to make it suitable for use by the recommendation system. This may involve removing duplicates or outliers, handling missing values, or aggregating data from multiple sources. 
4. Choose a Recommendation Algorithm: Select a recommendation algorithm that is appropriate for the type of data and the goals of the recommendation system. Common algorithms include collaborative filtering, content-based filtering, and matrix factorization. 
5. Train and Evaluate the Recommendation System: Use the data and the chosen algorithm to train the recommendation system. Evaluate the performance of the system using metrics such as accuracy, precision, or recall. 
6. Deploy the Recommendation System: Integrate the recommendation system into the application or platform where it will be used, and test it to ensure it is working as expected. 

1. The service has a server that stores video content and handles requests from clients. 
2. Clients can be users accessing the service through a web browser or a mobile app, or devices such as smart TVs or streaming media players. 
3. The server maintains a database of users, their subscriptions and payment information, and their watch history. It also stores information about the video content, including titles, descriptions, tags, and ratings. 
4. When a user logs in to the service, the server retrieves their account information and sends it to the client. The client displays the user's personalized home screen, which shows recommendations based on the user's watch history and preferences. 
5. The user can search for and browse the available content, or they can subscribe to channels to receive updates when new videos are posted. The client sends requests to the server to retrieve the requested content. 
6. The server streams the selected video to the client, and the client plays the video on the user's device. The client records the user's progress through the video and sends this information back to the server. The server updates the user's watch history and uses it to make recommendations to the user in the future. 
7. The service has a payment system for handling subscriptions and any additional charges (such as rental fees for individual movies). The server communicates with the payment system to process transactions and update the user's account balance. 

1. The traffic control system has a server that manages the traffic signals and handles requests from clients. 
2. Clients can be traffic control operators or traffic management systems that need to communicate with traffic signals. Clients connect to the server through a user interface, such as a website or a mobile app. 
3. The server maintains a database of traffic signals and their current status (such as green, yellow, or red). It also stores information about the roads and intersections that the traffic signals control, as well as any special rules or conditions (such as construction or events). 
4. The server receives input from sensors and cameras at the intersections, which provide real-time data on the traffic flow and conditions. The server uses this data to adjust the timing and patterns of the traffic signals as needed to optimize the flow of traffic. 
5. Traffic control operators can use the client UI to manually override the traffic signals or set special rules (such as turning all the signals red during an emergency). The server updates the traffic signals as requested and sends a confirmation to the operator. 
6. Traffic management systems (such as those used by public transportation) can use the client UI to request priority for their vehicles at intersections. The server adjusts the traffic signals to give priority to the requested vehicles. 

• Start by defining the goals of the system and the types of ads it should support (such as display ads, video ads, or native ads). Gather data on the available ad inventory, including information on the ad formats, sizes, and targeting options.Also gather data on the advertisers who will be bidding for ad space, including their budgets, targeting preferences, and bid strategies. 
• Design a system for storing and managing the ad inventory and advertiser data. This could involve using a database or a distributed storage system to store the data, as well as implementing processes for adding, updating, and deleting data as needed. 
• Design a system for matching ads to available inventory. This could involve using algorithms to match ads to inventory based on factors such as targeting, ad format, and budget, or it could involve implementing a marketplace where advertisers can bid on specific ad slots. 
• To enable real-time bidding, design a system for processing bids and selecting the winning bid in real-time. This could involve using an auction-based approach, where bids are processed and the winning bid is selected based on the highest bid, or it could involve using a first-price auction approach, where the winning bid is selected based on the bid that is closest to the ad's true value. 
• Lastly, design a system for tracking and reporting on the performance of the ads and the effectiveness of the bidding system.

• Start by gathering data on past fraud cases and identifying common patterns or characteristics of fraudulent transactions. This could involve analyzing data such as the types of products or services being purchased, the locations of the transactions, the payment methods being used, and the behavior of the users involved. 
• Design a system for monitoring and analyzing ongoing transactions in real time. This could involve implementing a machine learning model that is trained on past fraud data and can detect patterns or anomalies that may indicate fraudulent activity. The system could also incorporate additional data sources, such as data from third-party fraud detection services or information on the user's device or IP address. 
• To prevent fraudulent transactions, design a system for blocking or flagging transactions that the system has identified as potentially fraudulent. This could involve automatically rejecting the transaction or requiring additional authentication or verification from the user before proceeding with the transaction. 
• Design a system for reviewing and investigating flagged transactions to determine if they are fraudulent. This could involve assigning the flagged transactions to a team of fraud analysts who can review the transactions and make a decision on whether to approve or reject them. 
• In the end, design a system for tracking and reporting on the performance of the fraud detection system, including metrics such as the number of fraudulent transactions detected, the number of false positives, and the overall effectiveness of the system. Also, regularly update and improve the system based on new data.

1. Start by gathering data on the available resources (such as doctors, exam rooms, and equipment) and the types of appointments that can be scheduled (such as regular check-ups, specialist appointments, or surgeries). Also gather data on the patients, including their personal and contact information, insurance details, and medical history. 
2. Design a system for storing and managing the resource and patient data. This could involve using a database or a distributed storage system to store the data, as well as implementing processes for adding, updating, and deleting data as needed. 
3. Design a system for scheduling appointments that takes into account the availability of resources, the preferences of the patients and doctors, and any constraints or rules (such as the need for certain types of equipment or the requirement for advance notice). This could involve using a scheduling algorithm that optimizes the use of resources and minimizes conflicts, or it could involve implementing a calendar-based system where appointments can be manually scheduled by the staff. 
4. To enable patients to schedule appointments online, design a system for allowing patients to browse the available appointments and select a time that works for them. This could involve integrating the scheduling system with a website or a mobile app that allows patients to view the available appointments and select one to book. 
5. Finally, design a system for managing and tracking appointments, including reminders for patients, notifications for staff, and the ability to reschedule or cancel appointments as needed. 

1. Gather data on the types of loans that the bank offers, the eligibility criteria for each loan, and the documents and information that are required for the loan application process. Also gather data on the potential borrowers, including their personal and financial information, credit history, and employment status. 
2. Design a system for storing and managing the loan and borrower data. This could involve using a database or a distributed storage system to store the data, as well as implementing processes for adding, updating, and deleting data as needed. 
3. Design a system for collecting and verifying the information that is required for the loan application process. This could involve implementing a web-based or mobile-based application form that borrowers can fill out and submit online, as well as a system for verifying the information that is provided (such as by checking with credit agencies or verifying employment status). 
4. To enable the bank to make decisions on loan applications, design a system for evaluating the loan applications based on the bank's eligibility criteria and risk assessment policies. This could involve using algorithms or models that are trained on past loan data to predict the likelihood of repayment, or it could involve manual review by loan officers. 
5. Finally, design a system for managing and tracking the loan application process, including the ability to communicate with borrowers and provide updates on the status of their applications, as well as the ability to track and report on the performance of the loan portfolio. Also design a system for handling rejected loan applications, including the ability to provide feedback to borrowers on the reasons for the rejection and suggest alternative options if applicable.

• Data Source: The first step is to identify the source of the data stream and determine how it will be ingested into the system. This might involve connecting to a real-time data feed or setting up a system to continuously collect data from a source such as social media or sensor networks. 
• Data Processing: The system should have the ability to process the data stream in real time as it is ingested. This might involve applying transformations or aggregations to the data, filtering out irrelevant or duplicate information, or triggering alerts based on certain conditions. 
• Data Storage: The system should have a system in place for storing the processed data, either in a database or some other type of storage system. This data should be easily accessible and queryable for further analysis or visualization. 
• Scalability: To handle a large volume of data, the system should be designed to scale horizontally by adding additional processing nodes as needed. This might involve using a distributed processing framework such as Apache Spark or Flink. 
• Fault Tolerance: To ensure that the system can continue to operate even in the event of failures or outages, the system should be designed with fault tolerance in mind. This might involve replicating data across multiple nodes or using a distributed consensus algorithm to ensure data consistency. 
• Monitoring and Management: The system should have a system in place for monitoring the performance and availability of the system, as well as tools for managing and maintaining the system over time. This might involve using a monitoring platform such as Prometheus or a management tool such as Ansible. 

A staple in System design interview questions, be prepared to answer this one.  

A staple in Software design interview questions, be prepared to answer this one.  

1. Use Multiple Availability Zones: Many cloud providers, such as Amazon Web Services (AWS) and Microsoft Azure, offer multiple availability zones within a region. These are physically separate locations within a region that are connected through low-latency, high-bandwidth networking. By deploying the compute cluster across multiple availability zones, you can ensure that the cluster is resilient to outages in a single location. 
2. Use a Load Balancer: A load balancer can be used to distribute traffic across multiple compute instances in the cluster. This can help to ensure that the cluster can handle a high volume of traffic and can continue to operate if one or more instances fail. 
3. Use Auto-scaling: Auto-scaling allows you to automatically increase or decrease the number of compute instances in the cluster based on demand. This can help to ensure that the cluster has the capacity to handle peak traffic and can recover from a failure by automatically adding new instances. 
4. Use a Managed Service: Many cloud providers offer managed services, such as managed Kubernetes clusters, that handle the underlying infrastructure and provide built-in redundancy. Using a managed service can simplify the process of building redundancy into the compute cluster. 
5. Use a Multi-cloud Strategy: Another option is to deploy the compute clusters across multiple cloud providers, such as AWS and Azure. This can provide additional redundancy and ensure that the cluster can continue operating in the event of an outage at one of the providers. 

Answering system design questions like this will require you to have hands-on experience. Here is how to design this wearable.

• Hardware: The wearable should have a hardware component that is small, lightweight, and comfortable to wear. This might include a strap or band that can be worn around the chest or wrist and a sensor that can accurately measure heart rate. 
• Data Display: The wearable should have a display that allows users to view their heart rate in real-time, as well as other relevant data such as their activity level and calories burned. The display should be easy to read and navigate, with a user-friendly interface. 
• Connectivity: The wearable should have the ability to connect to a smartphone or other device, either through Bluetooth or a wireless connection. This will allow users to access their heart rate data and track their progress over time. 
• Battery Life: The wearable should have a long battery life to ensure that it can be worn throughout the day without requiring frequent charging. 
• Water Resistance: To allow for use during activities such as swimming, the wearable should be water-resistant to a certain level. 
• Wearability: The wearable should be comfortable to wear and easy to adjust, with options for different sizes and fits. It should also be durable and able to withstand everyday wear and tear. 
• Data Analysis: The wearable should have the ability to analyze and interpret the heart rate data, potentially providing insights and recommendations to users based on their activity level and overall health. 

1. Set up the Memcache Servers: The first step is to set up the Memcache servers that will be used to store and retrieve data. This might involve installing the Memcache software and configuring the servers to meet the needs of the system. 
2. Configure the Load Balancer: Next, the load balancer should be configured to distribute incoming requests to the Memcache servers. This might involve specifying the IP addresses and port numbers of the servers, as well as setting up any required authentication or security measures. 
3. Set up the Client Application: The client application that will be used to access the Memcache servers should be configured to use the load balancer as the endpoint for requests. This might involve updating the application's configuration to specify the IP address and port number of the load balancer. 
4. Test and Monitor: The system should be tested to ensure that it is working as expected and that the load balancer is effectively distributing requests to the Memcache servers. Ongoing monitoring can be used to track the performance and availability of the system and identify any issues that arise. 

A distributed system that can index and search a large dataset should be designed as per these considerations -

• Data Ingestion: The first step is to determine how the data will be ingested into the system. This might involve connecting to a data source, such as a database or file system, or setting up a system to continuously collect data from a stream. 
• Data Indexing: The system should have a system in place for indexing the data, which involves creating a data structure that allows for fast search and retrieval. This might involve using techniques such as inverted indexes or document-oriented databases. 
• Data Distribution: To scale the system to handle a large dataset, the data should be distributed across a cluster of nodes. This might involve using a partitioning scheme such as consistent hashing or a more sophisticated approach such as a distributed hash table. 
• Query Processing: The system should have a system in place for processing search queries, including the ability to parse and interpret the query, retrieve the relevant data from the index, and return the results to the user. 
• Performance: The system should be designed for high performance, with the ability to handle a large volume of search queries in a short period. This might involve using techniques such as caching or sharding to distribute the load across the cluster. 
• Monitoring and Management: The system should have a system in place for monitoring the performance and availability of the system, as well as tools for managing and maintaining the system over time. This might involve using a monitoring platform such as Prometheus or a management tool such as Ansible. 

Expect to come across this popular question in System design interviews.

Here is how we can design the Server Architecture for a platform like Gmail.

1. Load Balancing: Gmail handles a large volume of incoming and outgoing email traffic, so you would need to design a load balancing system to distribute traffic across multiple servers to ensure that the service remains available and responsive. 
2. Data Storage: Gmail stores a large amount of data, including emails, attachments, and user account information. We would need to determine how to store this data, including deciding on the type of storage (e.g. disk or cloud-based) and how to replicate and backup data to ensure its durability and availability. 
3. Data Processing: Gmail processes a large volume of data in real-time, including tasks such as filtering spam, indexing emails for search, and applying labels and filters. We would need to design a system to handle these tasks efficiently and effectively. 
4. Security: Security is a critical consideration when designing the server infrastructure for Gmail. We need to implement measures to protect against cyber attacks and ensure that user data is secure. 
5. Scalability: As Gmail is a widely-used service, it is important to design the server infrastructure to be scalable so that it can handle increases in traffic and data processing demands. This may involve designing the system to be able to easily add or remove servers as needed. 

A must-know for anyone heading into an interview, this question is frequently asked in Front-end System design interviews.  

We can design a system like Google Photos by following the steps below -

• Gather Requirements: The first step in designing a system for Google Photos would be to gather requirements and define the scope of the project. This might involve identifying the specific features and functionality that the system should include, as well as any constraints or limitations that need to be taken into account. 
• Identify User Needs: The next step would be to identify the needs and expectations of the users who will be interacting with the system. This might involve conducting user research or user testing to gather insights about how people currently use photo-sharing services and what they would like to see in a new system. 
• Develop a Plan: Based on the requirements and user needs identified in the previous steps, the design team would then develop a plan for implementing the system. This might involve creating wireframes or prototypes to visualize the user interface, as well as developing a technical architecture for the system. 
• Design the User Interface: Once the overall plan for the system has been developed, the design team would then focus on designing the user interface (UI) for the system. This would involve creating visual designs, such as mockups and prototypes, to demonstrate how the system will look and feel to users. 
• Implement the System: Once the design of the system has been finalized, the implementation phase can begin. This would involve building and testing the system, integrating it with any necessary backend systems, and deploying it to users.

System design interview questions can be asked from other similar scenarios like this.

To design services like these, we consider the following points -

• Which features are some of the requirements? 
  • On the internet, users should be able to upload, delete, share, and download files. 
  • File updates should sync between several devices. 
• What are some typical issues that arise? 
  • Where should the files be kept? 
  • How well do you handle changes? Should the original files be posted again, or simply the new version with the changes? 
  • How should two documents be updated simultaneously? 
• The potential pointers 
  • Consider employing chunking to separate files into many portions to permit re-uploads of a specific section rather than the entire file, as possible advice. 
  • Use cloud storage to keep the files safe. 

This is a common question in Software design interviews, don't miss this one.

One of the most frequently posed Software design questions, be ready for it.  

• Data Sources: Google Maps uses a variety of data sources, including satellite imagery, aerial photography, and map data from third-party providers, to create its maps. You would need to determine which data sources to use and how to integrate them into the map. 
• User Interface: The user interface (UI) of Google Maps is designed to be simple and intuitive, allowing users to easily navigate and search for locations. You would need to consider how to design the UI, including the layout, color scheme, and font choices, to ensure that it is user-friendly. 
• Features and Functionality: Google Maps offers a range of features and functionality, such as the ability to search for and locate addresses, businesses, and points of interest, as well as to get directions and view traffic conditions. You would need to decide which features to include and how to implement them. 
• Mobile Compatibility: Google Maps is also available on mobile devices, so you would need to consider how to design the map for use on small screens and how to optimize the map for mobile use. 
• Testing and Debugging: Before launching Google Maps, you would need to thoroughly test and debug the map to ensure that it is accurate and reliable. This would involve identifying and fixing any errors or issues that arise during testing. 

• Customer Database: This component would store customer information such as contact details and credit card information. It could be implemented using a database or a distributed key-value store. 
• Purchase Tracking System: This component would track purchases made by customers using a credit card. It could be implemented using a database or a distributed key-value store and could be integrated with the customer database to associate purchases with specific customers. 
• Promotion Engine: This component would handle the logic for applying the cash-back promotion to eligible purchases. It could be implemented using a set of rules or algorithms and could be integrated with the purchase tracking system to determine which purchases are eligible for the promotion. 
• Notification System: This component would handle sending notifications to customers about the promotion and their cash-back credits. It could be implemented using a messaging system such as SMS or email and could be integrated with the customer database to ensure that notifications are sent to the correct customers. 
• Cash Back Application System: This component would handle crediting the cash back to the customer's account or applying it as a statement credit on the credit card. It could be implemented using APIs or integrations with the credit card issuer's systems. 
• Monitoring and Reporting System: This component would handle tracking and reporting on the promotion, including metrics such as the number of eligible purchases, the total amount of cashback credited, and customer feedback. It could be implemented using data analysis tools or customer feedback systems. 

A staple in System design questions and answers, be prepared to answer this one.  

• Identify the Data Sources: The newsfeed should be able to aggregate data from a variety of sources, such as posts from friends, pages that a user has liked, and ads. This data should be stored in a central repository such as a database or a data lake. 
• Design the Data Processing Pipeline: The data processing pipeline should be responsible for extracting, transforming, and loading the data from the various sources into the central repository. It could be implemented using a distributed data processing platform such as Apache Hadoop or Apache Spark. 
• Develop the Ranking Algorithm: The ranking algorithm should be responsible for determining the order in which the items in the newsfeed are displayed to the user. It should take into account factors such as the user's past engagement with similar content, the user's relationships with the sources of the content, and the relevance of the content to the user. The ranking algorithm could be implemented using machine learning techniques such as matrix factorization or neural networks. 
• Design the User Interface: The user interface should allow the user to view the newsfeed and interact with the content. It should be optimized for performance and should support features such as infinite scrolling and lazy loading. 
• Implement Monitoring and Maintenance: The system should include components for monitoring the performance and reliability of the various components and for providing tools for maintenance and troubleshooting. This could include features such as logging, alerting, and remote access. 
• Implement Security: The system should include security measures to protect the privacy of the user's data and prevent unauthorized access to the system. This could include measures such as authentication and authorization, encryption, and firewall protection.

The API layers for Facebook chat will include

• Authentication: The API should require users to authenticate using their Facebook credentials to use the chat feature. This can be done using OAuth, a standard protocol for authorization. 
• Endpoints: The API should provide a set of endpoints that allow developers to perform various actions within the chat feature. These might include creating a new chat, sending and receiving messages, and updating chat metadata. 
• Data Formatting: The API should specify the format in which data is sent and received, such as JSON or XML. It should also include documentation on the structure of the data, including any required fields and the types of values that can be passed. 
• Error Handling: The API should include a robust error handling system to provide clear and actionable error messages to developers if something goes wrong. 
• Rate Limiting: To prevent excessive use of the API and protect against abuse, the API should implement rate limiting to limit the number of requests that can be made in a given period. 
• Security: The API should implement appropriate security measures to protect user data and prevent unauthorized access. This might include measures such as encryption and secure communication protocols.

This is a regular feature in the list of top System design questions, be ready to tackle it.  

• Gather Requirements: The first step in designing a system for searching Facebook statuses would be to gather requirements and define the scope of the project. This might involve identifying the specific features and functionality that the system should include, as well as any constraints or limitations that need to be taken into account. 
• Identify User Needs: The next step would be to identify the needs and expectations of the users who will be interacting with the system. This might involve conducting user research or user testing to gather insights about how people currently search for statuses on Facebook and what they would like to see in a new system. 
• Develop a Plan: Based on the requirements and user needs identified in the previous steps, the design team would then develop a plan for implementing the system. This might involve creating wireframes or prototypes to visualize the user interface, as well as developing a technical architecture for the system. 
• Design the User Interface: Once the overall plan for the system has been developed, the design team would then focus on designing the user interface (UI) for the system. This would involve creating visual designs, such as mockups and prototypes, to demonstrate how the system will look and feel to users. 
• Implement the System: Once the design of the system has been finalized, the implementation phase can begin. This would involve building and testing the system, integrating it with any necessary backend systems, and deploying it to users. 

This can be done by considering the following factors.

• Authentication: The API should require users to authenticate using a secure method, such as an API key or OAuth, to access the API. 
• Endpoints: The API should provide a set of endpoints that allow developers to perform various actions related to order events, such as creating a new order, updating an existing order, or retrieving order details. 
• Data Formatting: The API should specify the format in which data is sent and received, such as JSON or XML. It should also include documentation on the structure of the data, including any required fields and the types of values that can be passed. 
• Error Handling: The API should include a robust error handling system to provide clear and actionable error messages to developers if something goes wrong. 
• Rate Limiting: To prevent excessive use of the API and protect against abuse, the API should implement rate limiting to limit the number of requests that can be made in a given period. 
• Security: API should implement appropriate security measures to protect user data and prevent unauthorized access. This might include measures such as encryption and secure communication protocols. 
• Order Organization: API must have a system in place to organize and track order events, such as creating a unique identifier for each order and storing relevant information such as the customer's name, the items ordered, and the order status. This information should be easily accessible and searchable through the API. 

We can design a distributed system for storing and processing large amounts of structured and unstructured data with the following considerations.

• Data Ingestion: The first step is to determine how the data will be ingested into the system. This might involve connecting to a data source, such as a database or file system, or setting up a system to continuously collect data from a stream.
• Data Storage: The system should have a system in place for storing the data, such as a distributed file system or a distributed database. This system should be able to handle a large volume of data and support both structured and unstructured data.
• Data Processing: The system should have the ability to process the data in real-time or near real-time, potentially applying transformations or aggregations to the data, filtering out irrelevant or duplicate information, or triggering alerts based on certain conditions.
• Data Analysis: The system should have the ability to analyze the data and extract insights, potentially using tools such as machine learning algorithms or data visualization tools.
• Scalability: To handle a large volume of data, the system should be designed to scale horizontally by adding additional processing and storage nodes as needed.
• Fault Tolerance: To ensure that the system can continue to operate even in the event of failures or outages, the system should be designed with fault tolerance in mind. This might involve replicating data across multiple nodes or using a distributed consensus algorithm to ensure data consistency.
• Monitoring and Management: The system should have a system in place for monitoring the performance and availability of the system, as well as tools for managing and maintaining the system over time. This might involve using a monitoring platform such as Prometheus or a management tool such as Ansible.

It's no surprise that this one pops up often as one of the top System design interview questions.