10 System Design Interview

Questions (With Answers) I

Wished I Knew Before the
Interview

System design interviews have become an essential aspect of the

hiring process in the tech industry, with top companies like Google,
Facebook, and Amazon relying heavily on them to evaluate a
candidate’s ability to design and optimize large-scale systems.

I have had helped hundreds of candidates navigate this challenge. In

my experience, acing a system design interview requires not only a
strong understanding of the fundamental concepts but also the
ability to communicate your thought process clearly and efficiently.
This is where most candidates struggle, as they may have the
knowledge but are unable to express it in a manner that resonates
with their interviewers.

In this article, I’ll share the top 10 system design interview

questions that I have encountered through my interview
experiences with major tech companies. I’ve chosen these questions
based on their frequency in interviews. Moreover, I’ll provide you
with a step-by-step approach to answering each question effectively,
along with practical tips and best practices that you can incorporate
into your own interview preparation.
Entry-Level Candidates vs. Experienced Professionals
There’s a stark difference in the expectations for entry-level
candidates and experienced professionals during system design
interviews.

For Entry-Level Candidates: If you’re fresh out of college or

have less than two years of experience, interviewers are often
lenient. They don’t expect you to design Facebook’s backend.
Instead, they look for a solid understanding of basic system design
principles and the capability to think logically. For instance, a typical
question might be about designing a simple ticket booking system or
understanding database schemas.

Example: Did you know? According to Glassdoor, about 12% of

entry-level software engineer interviews focus on basic system
design, to ensure a foundational grasp.

For Experienced Professionals: As you climb the experience

ladder, the intricacy of the questions ramps up. Now, interviewers
will focus on scalability, data consistency, and high-level design
principles. You might be asked to design a global distributed system
or optimize a social media platform for millions of users.

Example: Surprising Stat: On a study conducted by Hired.com, it

was found that over 48% of senior engineers faced complex system
design questions in their interviews.
Let’s start with a small description of top 10 system design
questions.

The Top 10 System Design Interview Questions:

1. Design a URL Shortening Service (e.g., bit.ly)

This question assesses your ability to design a service that can

generate short, unique URLs for longer web addresses. Key concepts
include hashing, database design, and API development.

2. Design a Scalable Rate Limiter

Rate limiters are crucial in protecting systems from being

overwhelmed by a high volume of requests. This question tests your
understanding of distributed systems and techniques like token
bucket or leaky bucket algorithms.

3. Design Twitter or a Similar Social Media Platform

Designing a social media platform like Twitter requires you to

consider various aspects such as user registration,
following/follower relationships, tweeting, and timeline generation.
This question evaluates your skills in designing scalable and fault-
tolerant systems.

4. Design a Web Crawler

A web crawler is used to extract information from websites and

index it for search engines. In this question, you’ll need to showcase
your knowledge of web technologies, parallel processing, and data
storage.
5. Design an Online Chat System (e.g., WhatsApp or Slack)

This question challenges you to create a system that supports real-

time messaging, group chats, and offline message delivery. Key
considerations include message storage, data synchronization, and
efficient communication protocols.

6. Design a Distributed File System (e.g., HDFS or Amazon S3)

Distributed file systems are essential for storing and managing large
amounts of data across multiple machines. This question gauges
your understanding of distributed systems, data replication, and
consistency models.

7. Design a Load Balancer

Load balancers help distribute incoming network traffic across

multiple servers to ensure high availability and fault tolerance. This
question requires a strong grasp of networking concepts, algorithms,
and session management.

8. Design a Content Delivery Network (CDN)

A CDN is a system that caches and serves content from servers

located closer to end-users, improving performance and reducing
latency. This question tests your ability to optimize content delivery
while managing cache consistency and resource allocation.

9. Design an API Rate Limiter

API rate limiting is crucial for maintaining the stability and security
of a web service. This question focuses on your understanding of API
design, token-based authentication, and rate-limiting algorithms.
10. Design a Key-Value Store (e.g., Redis or Amazon DynamoDB)

Key-value stores are used for fast, scalable data storage and
retrieval. This question evaluates your skills in database design,
caching mechanisms, and data replication and partitioning
strategies.

By preparing for these top 10 system design interview questions,

you’ll have a solid foundation for handling a wide variety of design
problems that you may encounter during your interviews. Keep in
mind that interviewers are not only interested in your final solution
but also the thought process and trade-offs you consider while
designing the system. As you practice answering these questions,
focus on developing a structured step-by-step approach that
takes into account the scalability, reliability, and efficiency of the
system you’re designing. And most importantly, don’t forget to
communicate your ideas clearly and effectively, as this is a crucial
skill that interviewers will be assessing throughout the process.

Demystifying System Design Interviews: A Guide

Struggling with system design interviews? Unlock expert guidance, strategies, and
practice questions to ace your…
www.designgurus.io

How to Answer Each Question

Here is detailed guideline on answering each of these system design
interview question:

1. Design a URL Shortening Service (e.g., bit.ly)

URL Shortening Service: bit.ly and goo.gl are popular URL
shortening services that generate unique short URLs, provide
analytics, and efficiently redirect users to the original URL.

High-level Design of URL Shortening Service

Here are the key design points:

 Understand the requirements: Identify the key features,

such as URL shortening, redirection, and analytics.
 Make assumptions: Define the expected number of users,
requests, and storage capacity.
 Choose a hashing algorithm: Select an algorithm like MD5
or Base62 to generate unique short URLs.
 Design the database: Use a key-value store or relational
database to store mappings between the original and
shortened URLs.
 Develop APIs: Create RESTful APIs for shortening URLs
and redirecting users to the original URL.
  Consider edge cases: Handle duplicate URLs, collisions,
and expired URLs.
 Optimize for performance: Use caching mechanisms, such
as Redis or Memcached, to speed up redirection.

2. Design a Scalable Rate Limiter

Cloudflare and Amazon API Gateway are examples of services that

offer scalable rate limiting features to protect web applications and
APIs from excessive requests and abuse.

Here are the key design points:

 Understand the requirements: Determine the rate-limiting

policy, such as requests per minute or per second.
 Choose a rate-limiting algorithm: Use token bucket or leaky
bucket algorithms based on the desired behavior.
 Design the data storage: Store user tokens in-memory or
use a distributed data store like Redis.
 Implement middleware: Create middleware to handle rate-
limiting logic before requests reach the main application.
 Handle distributed systems: Use a consistent hashing
algorithm to distribute tokens across multiple servers.
 Monitor and adjust: Continuously monitor the system’s
performance and adjust rate limits as needed.

3. Design Twitter or a Similar Social Media Platform

Twitter and Facebook are examples of large-scale social media

platforms that handle user registration, relationships, posting, and
timeline generation while managing massive amounts of data and
traffic.

Here are the key design points:

 Understand the requirements: Identify the main features,

such as user registration, following/follower relationships,
tweeting, and timeline generation.
 Design the data models: Define the schema for users,
tweets, and relationships.
 Choose the right database: Use a combination of databases,
such as relational databases for user data and NoSQL
databases for tweets and relationships.
 Implement APIs: Develop RESTful APIs for user
registration, tweeting, and timeline generation.
 Optimize timelines: Use fan-out-on-write or fan-out-on-
read approaches to generate user timelines efficiently.
 Handle scalability: Use sharding, caching, and load
balancing to ensure the system remains performant under
high loads.
 Ensure fault tolerance: Implement data replication and
backup strategies to prevent data loss.

4. Design a Web Crawler

Googlebot and Bingbot are web crawlers used by Google and Bing
search engines, respectively, to crawl, index, and rank websites
based on various factors, such as relevance and popularity.
Web crawler high-level design

Here are the key design points:

 Understand the requirements: Define the scope of the

crawl, such as the number of websites, depth of crawling,
and types of content to be indexed.
 Choose the right crawling strategy: Implement breadth-first
search (BFS) or depth-first search (DFS) algorithms based
on the desired crawling behavior.
 Handle URLs: Use a URL frontier to store and manage the
URLs to be crawled.
 Design the parser: Create a parser to extract relevant
information from web pages, such as links, metadata, and
text.
 Store the data: Use a combination of databases, such as a
relational database for structured data and a NoSQL
database for unstructured data.
  Handle parallel processing: Implement parallelism using
multi-threading or distributed computing frameworks like
Apache Spark or Hadoop.
 Manage politeness: Respect website crawl-delay directives
and avoid overloading servers.

5. Design an Online Chat System

WhatsApp and Slack are examples of online chat systems that

support real-time messaging, group chats, and offline message
delivery while ensuring security and privacy through end-to-end
encryption.

Messeing app high-level design

Here are the key design points:

 Understand the requirements: Identify key features, such

as one-to-one messaging, group chats, and offline message
delivery.
 Design the data models: Define the schema for users,
messages, and chat rooms.
  Choose the right database: Use a combination of databases,
such as a relational database for user data and a NoSQL
database for messages and chat rooms.
 Implement communication protocols: Use WebSocket or
long polling for real-time messaging and HTTP for offline
message delivery.
 Design the message storage: Store messages in a
distributed database or message queue for scalability and
fault tolerance.
 Handle data synchronization: Implement mechanisms to
ensure messages are delivered and synchronized across
devices.
 Optimize performance: Use caching and indexing strategies
to speed up message retrieval and search.
 Ensure security and privacy: Implement end-to-end
encryption and authentication to protect user data and
communications.

6. Design a Distributed File System

Hadoop Distributed File System (HDFS) and Amazon S3 are widely

used distributed file systems designed to store and manage large
amounts of data across multiple machines while providing high
availability and fault tolerance.

Here are the key design points:

 Understand the requirements: Determine the expected

number of files, file sizes, and access patterns.
  Design the file system architecture: Use a master-slave or
peer-to-peer architecture based on the desired scalability
and fault tolerance.
 Handle file partitioning: Implement data partitioning
techniques, such as consistent hashing or range
partitioning, to distribute files across multiple nodes.
 Implement data replication: Use replication strategies like
quorum-based or eventual consistency to ensure data
durability and availability.
 Optimize data access: Implement caching and prefetching
strategies to improve read performance.
 Manage metadata: Use a centralized or distributed
metadata store to maintain file metadata and directory
structures.
 Handle fault tolerance and recovery: Implement
mechanisms to detect and recover from node failures, such
as heartbeat checks and automatic failover.

7. Design a Load Balancer

Amazon Elastic Load Balancing (ELB) and Google Cloud Load

Balancing are examples of cloud-based load balancers that
automatically distribute incoming traffic across multiple servers to
ensure high availability and fault tolerance.
Load balancing

Here are the key design points:

 Understand the requirements: Define the expected number

of clients, servers, and traffic patterns.
 Choose a load balancing algorithm: Implement algorithms
like round-robin, least connections, or least response time
based on the desired distribution behavior.
 Design the load balancer architecture: Use a hardware or
software-based load balancer depending on the required
performance and flexibility.
 Handle session persistence: Implement mechanisms like
sticky sessions or session affinity to ensure clients maintain
a consistent connection to a specific server.
 Manage health checks: Monitor server health and
automatically remove unhealthy servers from the load
balancer.
  Ensure fault tolerance: Implement redundant load
balancers and automatic failover mechanisms to prevent
single points of failure.

8. Design a Content Delivery Network (CDN)

Akamai and Cloudflare are leading content delivery networks that

cache and serve content from edge servers located closer to end-
users, improving performance and reducing latency.
Here are the key design points:

 Understand the requirements: Determine the types of

content to be served, the expected number of users, and
their geographic distribution.
  Design the CDN architecture: Use a hierarchical or flat
architecture based on the desired scalability and
performance.
 Implement caching strategies: Use cache eviction policies
like least recently used (LRU) or time-to-live (TTL) to
manage content in edge servers.
 Optimize content delivery: Implement techniques like
request routing, prefetching, and compression to improve
content delivery performance.
 Manage cache consistency: Implement cache invalidation
mechanisms to ensure up-to-date content is served to
users.
 Monitor and analyze performance: Collect and analyze
performance metrics to continuously optimize the CDN’s
performance and resource allocation.

9. Design an API Rate Limiter

GitHub and Google Maps API are examples of services that

implement API rate limiting to maintain stability and security while
allowing developers to access their resources within specified limits.

Here are the key design points:

 Understand the requirements: Define the rate-limiting

policy, such as requests per minute or per second, and the
scope of the rate limits (per user, IP address, or API
endpoint).
  Design the rate-limiting mechanism: Implement a fixed
window, sliding window, or token bucket algorithm based
on the desired rate-limiting behavior.
 Store rate-limiting data: Use in-memory data structures or
distributed data stores like Redis to store and manage rate-
limiting information.
 Implement middleware: Create middleware to handle rate-
limiting logic and enforce rate limits before requests reach
the main application.
 Handle distributed systems: Use a consistent hashing
algorithm or distributed locks to synchronize rate limits
across multiple servers.
 Monitor and adjust: Continuously monitor the system’s
performance and adjust rate limits as needed to balance
user experience and system stability.

10. Design a Key-Value Store

Redis and Amazon DynamoDB are popular key-value stores used for
fast, scalable data storage and retrieval, often utilized for caching,
session management, and real-time analytics.
Distributed key-value store

Here are the key design points:

 Understand the requirements: Determine the expected

number of keys, value sizes, and access patterns.
 Design the data partitioning: Implement data partitioning
techniques, such as consistent hashing or range
partitioning, to distribute keys across multiple nodes.
 Implement data replication: Use replication strategies like
master-slave or quorum-based to ensure data durability
and availability.
 Optimize data access: Implement caching and indexing
strategies to improve read and write performance.
  Handle data eviction: Use eviction policies like least
recently used (LRU) or time-to-live (TTL) to manage
memory usage.
 Ensure fault tolerance: Implement mechanisms to detect
and recover from node failures, such as heartbeat checks
and automatic failover.

As you prepare for your system design interviews, keep in mind that
these questions are meant to assess your ability to design scalable,
efficient, and reliable systems. It’s essential to understand the key
concepts and trade-offs involved in each problem and be able to
communicate your thought process clearly.

Practice answering these questions using a structured approach,

starting with understanding the requirements and making
assumptions, then moving on to designing the data models,
choosing the right databases and algorithms, and finally optimizing
the system for performance and fault tolerance. Be prepared to
discuss alternative solutions and justify your design choices.

Remember that interviewers are not only interested in your final

solution but also the thought process and trade-offs you consider
while designing the system. As you practice answering these
questions, focus on developing a structured approach that takes into
account the scalability, reliability, and efficiency of the system you’re
designing. And most importantly, don’t forget to communicate your
ideas clearly and effectively, as this is a crucial skill that interviewers
will be assessing throughout the process.
Common Mistakes and How to Avoid Them
When tackling system design interview questions, it’s essential to be
aware of common mistakes and understand how to avoid them.
Here are some key points to keep in mind:

 Not understanding the problem: It’s crucial to fully

understand the problem and its requirements before diving
into the design. Take the time to clarify any ambiguities and
ensure you have a clear understanding of the system’s
scope and goals.

How to avoid: Ask the interviewer questions to clarify

requirements, and don’t hesitate to restate the problem in your own
words to confirm your understanding.

 Jumping to a solution too quickly: Starting with a

solution before analyzing the problem and considering
alternatives can lead to suboptimal designs.

How to avoid: Take a step-by-step approach to analyze the

problem, identify key components, and explore different design
choices before settling on a solution.

 Ignoring scalability, reliability, and performance:

Failing to consider these factors can result in designs that
don’t meet the requirements of large-scale systems.
How to avoid: Keep scalability, reliability, and performance in
mind throughout the design process, and be prepared to discuss
trade-offs and optimizations related to these factors.

 Not discussing trade-offs: System design often involves

making trade-offs between various factors, such as
consistency vs. availability, or storage vs. computation.
Failing to discuss these trade-offs can leave interviewers
questioning your understanding of the problem.

How to avoid: Be proactive in discussing trade-offs and the

rationale behind your design choices. This shows interviewers that
you understand the complexities of system design and can make
informed decisions.

 Poor communication: Failing to clearly communicate

your thought process and design choices can make it
difficult for interviewers to assess your problem-solving
abilities and design skills.

How to avoid: Practice speaking clearly and concisely about your

design choices, and use diagrams or visual aids when appropriate to
help illustrate your points.

For more details, check my blog on what distinguish you

from others in a system design interview.

Useful Resources for System Design Interview Preparation

Navigating the vast sea of interview preparation can be daunting.
However, fear not! With the right resources, you can elevate your
understanding and position yourself as the top candidate. Let’s
spotlight some of the best tools and resources to help you stand out
in your system design interview.

a. Books and Online Courses

Ah, the age-old method of learning — but now with a digital twist!

 “Designing Data-Intensive Applications” by Martin

Kleppmann: Dubbed by many as the ‘Bible’ for system
design, this book delves deep into the challenges of creating
robust, scalable, and maintainable apps.
 “Grokking System Design Fundamentals” by Design
Gurus: Learn system design essentials required for
designing scalable and high-performance systems.
 “Grokking the System Design Interview” by Design
Gurus: Learn how to prepare for system design interviews
and practice common system design interview questions.

b. Mock Interview Services

There’s a saying: “Practice makes perfect.” But practicing in an

environment that mirrors the real thing? Even better.

 DesignGurus.io: This platform offers mock interviews by

FAANG engineers, covering a range of topics from
algorithms to system design.
  Interviewing.io: Get paired with engineers from top tech
companies like Google, Facebook, or Amazon, and receive
invaluable feedback on your performance.

Fun Fact: According to a survey by Indeed, over 70% of

candidates who used mock interview platforms felt more confident
and performed better in their real interviews.

Conclusion
Mastering system design interviews is a critical skill for tech
professionals seeking to advance their careers. In this blog, we’ve
covered the top 10 system design interview questions.

➡ Learn more about these questions in “Grokking the System

Design Interview” and “Grokking the Advanced System

Design Interview.”

As you prepare for your interviews, keep in mind that interviewers

are interested not only in your final solution but also in your thought
process and ability to make trade-offs. Focus on understanding the
requirements, analyzing the problem, and designing scalable,
efficient, and reliable systems while clearly communicating your
thought process and design choices.

Remember that practice is the key to success in system design

interviews. Work through various design problems, discuss
alternative solutions, and refine your skills in evaluating trade-offs
and making informed decisions. By doing so, you’ll be well on your
way to acing your system design interviews and securing your dream
tech job. Good luck, and happy system designing!

➡ Check Grokking System Design Fundamentals for a list of

common system design concepts.

Keep learn more on system design interviews:

To excel in system design, one of the most crucial aspects is to
develop a deep understanding of fundamental system design
concepts such as Load
Balancing, Caching, Partitioning, Replication, Databases,
and Proxies.

Through my own experiences, I’ve identified 16 key concepts that

can make a significant difference in your ability to tackle system
design problems. These concepts range from understanding the
intricacies of API gateway and mastering load-balancing techniques
to grasping the importance of CDNs and appreciating the role of
caching in modern distributed systems. By the end of this blog,
you’ll have a comprehensive understanding of these essential ideas
and the confidence to apply them in your next interview.

System design interviews are unstructured by nature. During the

interview, it is difficult to keep track of things and be sure that you
have touched upon all the essential aspects of the design. To simplify
this process, I have developed a system design master
template that should guide you in answering any system design
interview question. Take a look at the featured image to gain insight
into the key components that may be involved in any system design.

Keeping this master template in mind, we will discuss the

16 essential system design concepts. Here is their brief description:

1. Domain Name System (DNS)

2. Load Balancer
3. API Gateway
4. CDN
5. Forward Proxy vs. Reverse Proxy
6. Caching
7. Data Partitioning
8. Database Replication
9. Distributed Messaging Systems
10. Microservices
11. NoSQL Databases
12. Database Index
13. Distributed File Systems
14. Notification System
15. Full-text Search
16. Distributed Coordination Services

1. Domain Name System (DNS)

Domain Name System (DNS) is a fundamental component of the
internet infrastructure that translates human-friendly domain
names into their corresponding IP addresses. It functions like a
phonebook for the internet, allowing users to access websites and
services by typing in easily memorable domain names, such
as www.designgurus.iorather than the numerical IP addresses like
“192.0.2.1” that computers use to identify each other.

When you enter a domain name into your web browser, the DNS is
responsible for locating the associated IP address and directing your
request to the correct server. The process begins with your computer
sending a query to a recursive resolver, which then searches a series
of DNS servers, starting with the root server, followed by the Top-
Level Domain (TLD) server, and finally the authoritative name
server. Once the IP address is found, the recursive resolver returns it
to your computer, allowing your browser to establish a connection
with the target server and access the desired content.

DNS Resolver

2. Load Balancer
A load balancer is a networking device or software that distributes
incoming network traffic across multiple servers to ensure optimal
resource utilization, reduce latency, and maintain high availability.
It plays a vital role in scaling applications and managing server
workloads efficiently, especially in situations where there is a
sudden spike in traffic or uneven distribution of requests among
servers.

Load balancers use different algorithms to determine how to

distribute incoming traffic. Common algorithms include:
 1. Round Robin: Requests are distributed sequentially and
evenly across all available servers in a cyclical manner.
2. Least Connections: The load balancer assigns requests
to the server with the fewest active connections, prioritizing
less-busy servers.
3. IP Hash: The client’s IP address is hashed, and the
resulting value is used to determine which server the
request should be directed to. This method ensures that a
specific client’s requests are always routed to the same
server, helping maintain session persistence.

Load Balancer

3. API Gateway
An API Gateway is a server or service that acts as an intermediary
between external clients and the internal microservices or API-based
backend services of an application. It is a crucial component in
modern architectures, especially in microservices-based systems,
where it simplifies the communication process and provides a single
entry point for clients to access various services.
The main functions of an API Gateway include:

1. Request Routing: It directs incoming API requests from

clients to the appropriate backend service or microservice,
based on predefined rules and configurations.
2. Authentication and Authorization: The API Gateway
can handle user authentication and authorization, ensuring
that only authorized clients can access the services. It can
verify API keys, tokens, or other credentials before routing
requests to the backend services.
3. Rate Limiting and Throttling: To protect backend
services from excessive load or abuse, the API Gateway can
enforce rate limits or throttle requests from clients based
on predefined policies.
4. Caching: To reduce latency and backend load, the API
Gateway can cache frequently-used responses, serving
them directly to clients without the need to query the
backend services.
5. Request and Response Transformation: The API
Gateway can modify requests and responses, such as
converting data formats, adding or removing headers, or
modifying query parameters, to ensure compatibility
between clients and services.
API Gateway

Check Grokking the System Design Interview for a list

of common system design interview questions and basic
concepts.

4. CDN
A Content Delivery Network (CDN) is a distributed network of
servers that store and deliver content, such as images, videos,
stylesheets, and scripts, to users from geographically closer
locations. CDNs are designed to improve the performance, speed,
and reliability of content delivery to end-users, regardless of their
location relative to the origin server.

Here’s how a CDN works:

1. When a user requests content from a website or

application, the request is directed to the nearest CDN
server, also known as an edge server.
2. If the edge server has the requested content cached, it
directly serves the content to the user. This reduces latency
and improves the user experience, as the content travels a
shorter distance.
3. If the content is not cached on the edge server, the CDN
retrieves it from the origin server or another nearby CDN
server. Once the content is fetched, it is cached on the edge
server and served to the user.
4. To ensure the content remains up-to-date, the CDN
periodically checks the origin server for changes and
updates its cache accordingly.
5. Forward Proxy vs. Reverse Proxy
A forward proxy, also known as a “proxy server,” or simply
“proxy,” is a server that sits in front of one or more client machines
and acts as an intermediary between the clients and the internet.
When a client machine makes a request to a resource on the
internet, the request is first sent to the forward proxy. The forward
proxy then forwards the request to the internet on behalf of the
client machine and returns the response to the client machine.

A reverse proxy is a server that sits in front of one or more web

servers and acts as an intermediary between the web servers and the
Internet. When a client makes a request to a resource on the
internet, the request is first sent to the reverse proxy. The reverse
proxy then forwards the request to one of the web servers, which
returns the response to the reverse proxy. The reverse proxy then
returns the response to the client.

Forward Proxy vs. Reverse Proxy

Check Grokking the Advanced System Design

Interview for architectural reviews of famous distributed
systems.
6. Caching
The cache is a high-speed storage layer that sits between the
application and the original source of the data, such as a database, a
file system, or a remote web service. When data is requested by the
application, it is first checked in the cache. If the data is found in the
cache, it is returned to the application. If the data is not found in
the cache, it is retrieved from its original source, stored in the cache
for future use, and returned to the application. In a distributed
system, caching can be done at multiple places for example, Client,
DNS, CDN, Load Balancer, API Gateway, Server, Database, etc.

What are where to cache

7. Data Partitioning
In a database, horizontal partitioning, also known as sharding,
involves dividing the rows of a table into smaller tables and storing
them on different servers or database instances. This is done to
distribute the load of a database across multiple servers and to
improve performance.

On the other hand, vertical partitioning, involves dividing the

columns of a table into separate tables. This is done to reduce the
number of columns in a table and to improve the performance of
queries that only access a small number of columns.

Data partitioning

8. Database Replication
Database replication is a technique used to maintain multiple copies
of the same database across different servers or locations. The
primary purpose of database replication is to improve data
availability, redundancy, and fault tolerance, ensuring that the
system continues to function even in the case of hardware failures or
other issues.

In a replicated database setup, one server acts as the primary (or

master) database, while others function as replicas (or slaves). The
process involves synchronizing data between the primary database
and replicas, so they all have the same up-to-date information.
Database replication offers several benefits, including:

1. Improved Performance: By distributing read queries

among multiple replicas, you can reduce the load on the
primary database and improve query response times.
2. High Availability: In the event of a failure or downtime
on the primary database, replicas can continue to serve
data, ensuring uninterrupted access to the application.
3. Enhanced Data Protection: Having multiple copies of
the database across different locations helps protect against
data loss due to hardware failures or other disasters.
4. Load Balancing: Replicas can handle read queries, which
allows for better load distribution and reduces the overall
strain on the primary database.

Demystifying System Design Interviews: A Guide

Struggling with system design interviews? Unlock expert guidance, strategies, and
practice questions to ace your…
www.designgurus.io
9. Distributed Messaging Systems
Distributed messaging systems enable the exchange of messages
between multiple, potentially geographically-dispersed applications,
services, or components in a reliable, scalable, and fault-tolerant
manner. They facilitate communication by decoupling the sender
and receiver components, allowing them to evolve and operate
independently. Distributed messaging systems are particularly
useful in large-scale or complex systems, such as those found in
microservices architectures or distributed computing environments.
Examples of such systems are Apache Kafka and RabbitMQ.

10. Microservices
Microservices are an architectural style in which an application is
structured as a collection of small, loosely-coupled, and
independently deployable services. Each microservice is responsible
for a specific piece of functionality or domain within the application,
and communicates with other microservices through well-defined
APIs. This approach is a departure from the traditional monolithic
architecture, where an application is built as a single, tightly-coupled
unit.

The main characteristics of microservices are:

1. Single Responsibility: Each microservice focuses on a

specific functionality or domain, adhering to the Single
Responsibility Principle. This makes the services easier to
understand, develop, and maintain.
 2. Independence: Microservices can be developed,
deployed, and scaled independently of one another. This
allows for increased flexibility and agility in the
development process, as teams can work on different
services concurrently without impacting the entire system.
3. Decentralized: Microservices are typically decentralized,
with each service owning its data and business logic. This
encourages separation of concerns and enables teams to
make decisions and choose technologies that best suit their
specific requirements.
4. Communication: Microservices communicate with each
other using lightweight protocols such as HTTP/REST,
gRPC, or message queues. This promotes interoperability
and makes it easier to integrate new services or replace
existing ones.
5. Fault Tolerance: Since microservices are independent, a
failure in one service does not necessarily cause the entire
system to fail. This can help improve the overall resiliency
of the application.

11. NoSQL Databases

NoSQL databases, or “Not Only SQL” databases, are non-relational
databases designed to store, manage, and retrieve unstructured or
semi-structured data. They offer an alternative to traditional
relational databases, which rely on structured data and predefined
schemas. NoSQL databases have become popular due to their
flexibility, scalability, and ability to handle large volumes of data,
making them well-suited for modern applications, big data
processing, and real-time analytics.

NoSQL databases can be categorized into four main types:

1. Document-Based: These databases store data in

document-like structures, such as JSON or BSON. Each
document is self-contained and can have its own unique
structure, making them suitable for handling
heterogeneous data. Examples of document-based NoSQL
databases include MongoDB and Couchbase.
2. Key-Value: These databases store data as key-value pairs,
where the key acts as a unique identifier, and the value
holds the associated data. Key-value databases are highly
efficient for simple read and write operations, and they can
be easily partitioned and scaled horizontally. Examples of
key-value NoSQL databases include Redis and Amazon
DynamoDB.
3. Column-Family: These databases store data in column
families, which are groups of related columns. They are
designed to handle write-heavy workloads and are highly
efficient for querying data with a known row and column
keys. Examples of column-family NoSQL databases include
Apache Cassandra and HBase.
4. Graph-Based: These databases are designed for storing
and querying data that has complex relationships and
interconnected structures, such as social networks or
recommendation systems. Graph databases use nodes,
edges, and properties to represent and store data, making it
 easier to perform complex traversals and relationship-
based queries. Examples of graph-based NoSQL databases
include Neo4j and Amazon Neptune.

Types of NoSQL databases

12. Database Index

Database indexes are data structures that improve the speed and
efficiency of querying operations in a database. They work similarly
to an index in a book, allowing the database management system
(DBMS) to quickly locate the data associated with a specific value or
set of values, without having to search through every row in a table.
By providing a more direct path to the desired data, indexes can
significantly reduce the time it takes to retrieve information from a
database.

Indexes are usually built on one or more columns of a database

table. The most common type of index is the B-tree index, which
organizes data in a hierarchical tree structure, allowing for fast
search, insertion, and deletion operations. There are other types of
indexes, such as bitmap indexes and hash indexes, each with their
specific use cases and advantages.

While indexes can significantly improve query performance, they

also have some trade-offs:
 1. Storage Space: Indexes consume additional storage
space, as they create and maintain separate data structures
alongside the original table data.
2. Write Performance: When data is inserted, updated, or
deleted in a table, the associated indexes must also be
updated, which can slow down write operations.

Database Index

13. Distributed File Systems

Distributed file systems are storage solutions designed to manage
and provide access to files and directories across multiple servers,
nodes, or machines, often distributed over a network. They enable
users and applications to access and manipulate files as if they were
stored on a local file system, even though the actual files might be
physically stored on multiple remote servers. Distributed file
systems are often used in large-scale or distributed computing
environments to provide fault tolerance, high availability, and
improved performance.

14. Notification System

These are used to send notifications or alerts to users, such as
emails, push notifications, or text messages.
15. Full-text Search
Full-text search enables users to search for specific words or phrases
within an app or website. When a user queries, the app or website
returns the most relevant results. To do this quickly and efficiently,
full-text search relies on an inverted index, which is a data structure
that maps words or phrases to the documents in which they appear.
An example of such systems is Elastic Search.

16. Distributed Coordination Services

Distributed coordination services are systems designed to manage
and coordinate the activities of distributed applications, services, or
nodes in a reliable, efficient, and fault-tolerant manner. They help
maintain consistency, handle distributed synchronization, and
manage the configuration and state of various components in a
distributed environment. Distributed coordination services are
particularly useful in large-scale or complex systems, such as those
found in microservices architectures, distributed computing
environments, or clustered databases. Examples of such service are
Apache ZooKeeper, etcd, Consul.

Conclusion
Maximize your chances of acing system design interviews by using
the aforementioned system design concepts and the template. Here
is a list of common system design interview questions:

1. Designing a File-sharing Service Like Google Drive or

Dropbox.
 2. Designing a Video Streaming Platform
3. Designing a URL Shortening Service
4. Designing a Web Crawler
5. Designing Uber
6. Designing Facebook Messenger
7. Designing Twitter Search

Take a look at Grokking the System Design Interview for a

detailed discussion of such system design interview questions.

Check Grokking System Design Fundamentals for a list of

common system design concepts.

https://www.designgurus.io/blog/system-design-interview-
fundamentals

To learn software architecture and practice advanced system design

interview questions take a look at Grokking the Advanced
System Design Interview.

Keep learn more on system design interviews:

Why is Apache Kafka

Miraculously fast? — 7 Design
Principles
Apache Kafka is optimized for throughput at the
expense of latency and jitter, while preserving other
desirable qualities, such as durability, strict record
order, and at-least-once delivery semantics. When
someone says ‘Kafka is fast’, and assuming they are
at least mildly competent, you can assume they are
referring to Kafka’s ability to safely accumulate and
distribute a very high number of records in a short
amount of time.

1. Zero Copy Principle:

 Kafka achieves low latency message delivery through

Sequential I/O and Zero Copy Principle.

 The same techniques are commonly used in many other

messaging/streaming platforms. The diagram below
illustrates how the data is transmitted between producer
and consumer, and what zero-copy means.

 Here is the step-by-step explanation —

Image from — https://blog.bytebytego.com/p/why-is-kafka-fast

Step 1.1–1.3: Producer writes data to the disk

Step 2: Consumer reads data without zero-copy

2.1: The data is loaded from the disk to the OS cache

2.2 The data is copied from the OS cache to the Kafka application

2.3 Kafka application copies the data into the socket buffer

2.4 The data is copied from the socket buffer to the network card

2.5 The network card sends data out to the consumer

Step 3: Consumer reads data with zero-copy

3.1: The data is loaded from disk to the OS cache

3.2 OS cache directly copies the data to the network card via
sendfile() command

3.3 The network card sends data out to the consumer Zero copy is a
shortcut to save multiple data copies between the application
context and kernel context. This approach brings down the time by
approximately 65%.

2. Log-structured persistence

 Kafka utilizes a segmented, append-only log, largely

limiting itself to sequential I/O for both reads and writes,
which is fast across a wide variety of storage media.
  There is a wide misconception that disks are slow; however,
the performance of storage media (particularly rotating
media) is greatly dependent on access patterns.

3. Record batching

 There is a wide misconception that disks are slow; however,

the performance of storage media (particularly rotating
media) is greatly dependent on access patterns.

 In addition to the low-level batching provided by the OS,

Kafka clients and brokers will accumulate multiple records
in a batch — for both reading and writing — before sending
them over the network. Batching of records amortizes the
overhead of the network round-trip, using larger packets
and improving bandwidth efficiency.

4. Batch Compression

 The impact of batching is particularly obvious when

compression is enabled, as compression becomes generally
more effective as the data size increases. Especially when
using text-based formats such as JSON, the effects of
compression can be quite pronounced, with compression
ratios typically ranging from 5x to 7x.

 Furthermore, record batching is largely done as a client-

side operation, which transfers the load onto the client and
has a positive effect not only on the network bandwidth but
also on the brokers’ disk I/O utilization.

5. Cheap Consumers
  Consumers in Kafka are ‘cheap’, insofar as they don’t
mutate the log files (only the producer or internal Kafka
processes are permitted to do that). This means that a large
number of consumers may concurrently read from the
same topic without overwhelming the cluster.

 There is still some cost in adding a consumer, but it is

mostly sequential reads with a low rate of sequential writes.
So it’s fairly normal to see a single topic being shared across
a diverse consumer ecosystem.

6. Unflushed Buffered Writes

 Another fundamental reason for Kafka’s performance, and

one that is worth exploring further: Kafka doesn’t actually
call fsync when writing to the disk before acknowledging
the write; the only requirement for an ACK is that the
record has been written to the I/O buffer.

7. Avoiding the GC

 The heavy use of channels, native buffers, and the page

cache has one additional benefit — reducing the load on the
garbage collector (GC). For example, running Kafka on a
machine with 32 GB of RAM will result in 28–30 GB usable
for the page cache, completely outside of the GC’s scope.