English ∙ 日本語 ∙ 简体中文 ∙ 繁體中文 | العَرَبِيَّة‎ ∙ বাংলা ∙ Português do Brasil ∙ Deutsch ∙ ελληνικά ∙ עברית ∙ Italiano ∙ 한국어 ∙ فارسی ∙ Polski ∙ русский язык ∙ Español ∙ ภาษาไทย ∙ Türkçe ∙ tiếng Việt ∙ Français | Add Translation

Help translate this guide!

Learn how to design large-scale systems.

Prep for the system design interview.

Learning how to design scalable systems will help you become a better engineer.

System design is a broad topic. There is a vast amount of resources scattered throughout the web on system design principles.

This repo is an organized collection of resources to help you learn how to build systems at scale.

This is a continually updated, open source project.

Contributions are welcome!

In addition to coding interviews, system design is a required component of the technical interview process at many tech companies.

Practice common system design interview questions and compare your results with sample solutions: discussions, code, and diagrams.

Additional topics for interview prep:

• Study guide
• How to approach a system design interview question
• System design interview questions, with solutions
• Object-oriented design interview questions, with solutions
• Additional system design interview questions

The provided Anki flashcard decks use spaced repetition to help you retain key system design concepts.

• System design deck
• System design exercises deck
• Object oriented design exercises deck

Great for use while on-the-go.

Looking for resources to help you prep for the Coding Interview?

Check out the sister repo Interactive Coding Challenges, which contains an additional Anki deck:

• Coding deck

Learn from the community.

Feel free to submit pull requests to help:

• Fix errors
• Improve sections
• Add new sections
• Translate

Content that needs some polishing is placed under development.

Review the Contributing Guidelines.

Summaries of various system design topics, including pros and cons. Everything is a trade-off.

Each section contains links to more in-depth resources.

• System design topics: start here
  • Step 1: Review the scalability video lecture
  • Step 2: Review the scalability article
  • Next steps
• Performance vs scalability
• Latency vs throughput
• Availability vs consistency
  • CAP theorem
    • CP - consistency and partition tolerance
    • AP - availability and partition tolerance
• Consistency patterns
  • Weak consistency
  • Eventual consistency
  • Strong consistency
• Availability patterns
  • Fail-over
  • Replication
  • Availability in numbers
• Domain name system
• Content delivery network
  • Push CDNs
  • Pull CDNs
• Load balancer
  • Active-passive
  • Active-active
  • Layer 4 load balancing
  • Layer 7 load balancing
  • Horizontal scaling
• Reverse proxy (web server)
  • Load balancer vs reverse proxy
• Application layer
  • Microservices
  • Service discovery
• Database
  • Relational database management system (RDBMS)
    • Master-slave replication
    • Master-master replication
    • Federation
    • Sharding
    • Denormalization
    • SQL tuning
  • NoSQL
    • Key-value store
    • Document store
    • Wide column store
    • Graph Database
  • SQL or NoSQL
• Cache
  • Client caching
  • CDN caching
  • Web server caching
  • Database caching
  • Application caching
  • Caching at the database query level
  • Caching at the object level
  • When to update the cache
    • Cache-aside
    • Write-through
    • Write-behind (write-back)
    • Refresh-ahead
• Asynchronism
  • Message queues
  • Task queues
  • Back pressure
• Communication
  • Transmission control protocol (TCP)
  • User datagram protocol (UDP)
  • Remote procedure call (RPC)
  • Representational state transfer (REST)
• Security
• Appendix
  • Powers of two table
  • Latency numbers every programmer should know
  • Additional system design interview questions
  • Real world architectures
  • Company architectures
  • Company engineering blogs
• Under development
• Credits
• Contact info
• License

Suggested topics to review based on your interview timeline (short, medium, long).

Q: For interviews, do I need to know everything here?

A: No, you don't need to know everything here to prepare for the interview.

What you are asked in an interview depends on variables such as:

• How much experience you have
• What your technical background is
• What positions you are interviewing for
• Which companies you are interviewing with
• Luck

More experienced candidates are generally expected to know more about system design. Architects or team leads might be expected to know more than individual contributors. Top tech companies are likely to have one or more design interview rounds.

Start broad and go deeper in a few areas. It helps to know a little about various key system design topics. Adjust the following guide based on your timeline, experience, what positions you are interviewing for, and which companies you are interviewing with.

• Short timeline - Aim for breadth with system design topics. Practice by solving some interview questions.
• Medium timeline - Aim for breadth and some depth with system design topics. Practice by solving many interview questions.
• Long timeline - Aim for breadth and more depth with system design topics. Practice by solving most interview questions.

How to tackle a system design interview question.

The system design interview is an open-ended conversation. You are expected to lead it.

You can use the following steps to guide the discussion. To help solidify this process, work through the System design interview questions with solutions section using the following steps.

Gather requirements and scope the problem. Ask questions to clarify use cases and constraints. Discuss assumptions.

• Who is going to use it?
• How are they going to use it?
• How many users are there?
• What does the system do?
• What are the inputs and outputs of the system?
• How much data do we expect to handle?
• How many requests per second do we expect?
• What is the expected read to write ratio?

Outline a high level design with all important components.

• Sketch the main components and connections
• Justify your ideas

Dive into details for each core component. For example, if you were asked to design a url shortening service, discuss:

• Generating and storing a hash of the full url
  • MD5 and Base62
  • Hash collisions
  • SQL or NoSQL
  • Database schema
• Translating a hashed url to the full url
  • Database lookup
• API and object-oriented design

Identify and address bottlenecks, given the constraints. For example, do you need the following to address scalability issues?

• Load balancer
• Horizontal scaling
• Caching
• Database sharding

Discuss potential solutions and trade-offs. Everything is a trade-off. Address bottlenecks using principles of scalable system design.

You might be asked to do some estimates by hand. Refer to the Appendix for the following resources:

• Use back of the envelope calculations
• Powers of two table
• Latency numbers every programmer should know

Check out the following links to get a better idea of what to expect:

• How to ace a systems design interview
• The system design interview
• Intro to Architecture and Systems Design Interviews
• System design template

Common system design interview questions with sample discussions, code, and diagrams.

Solutions linked to content in the solutions/ folder.

View exercise and solution

View exercise and solution

View exercise and solution

View exercise and solution

View exercise and solution

View exercise and solution

View exercise and solution

View exercise and solution

Common object-oriented design interview questions with sample discussions, code, and diagrams.

Solutions linked to content in the solutions/ folder.

Note: This section is under development

New to system design?

First, you'll need a basic understanding of common principles, learning about what they are, how they are used, and their pros and cons.

Scalability Lecture at Harvard

• Topics covered:
  • Vertical scaling
  • Horizontal scaling
  • Caching
  • Load balancing
  • Database replication
  • Database partitioning

Scalability

• Topics covered:
  • Clones
  • Databases
  • Caches
  • Asynchronism

Next, we'll look at high-level trade-offs:

• Performance vs scalability
• Latency vs throughput
• Availability vs consistency

Keep in mind that everything is a trade-off.

Then we'll dive into more specific topics such as DNS, CDNs, and load balancers.

A service is scalable if it results in increased performance in a manner proportional to resources added. Generally, increasing performance means serving more units of work, but it can also be to handle larger units of work, such as when datasets grow.¹

Another way to look at performance vs scalability:

• If you have a performance problem, your system is slow for a single user.
• If you have a scalability problem, your system is fast for a single user but slow under heavy load.

• A word on scalability
• Scalability, availability, stability, patterns

Latency is the time to perform some action or to produce some result.

Throughput is the number of such actions or results per unit of time.

Generally, you should aim for maximal throughput with acceptable latency.

• Understanding latency vs throughput

Source: CAP theorem revisited

In a distributed computer system, you can only support two of the following guarantees:

• Consistency - Every read receives the most recent write or an error
• Availability - Every request receives a response, without guarantee that it contains the most recent version of the information
• Partition Tolerance - The system continues to operate despite arbitrary partitioning due to network failures

Networks aren't reliable, so you'll need to support partition tolerance. You'll need to make a software tradeoff between consistency and availability.

Waiting for a response from the partitioned node might result in a timeout error. CP is a good choice if your business needs require atomic reads and writes.

Responses return the most readily available version of the data available on any node, which might not be the latest. Writes might take some time to propagate when the partition is resolved.

AP is a good choice if the business needs to allow for eventual consistency or when the system needs to continue working despite external errors.

• CAP theorem revisited
• A plain english introduction to CAP theorem
• CAP FAQ
• The CAP theorem

With multiple copies of the same data, we are faced with options on how to synchronize them so clients have a consistent view of the data. Recall the definition of consistency from the CAP theorem - Every read receives the most recent write or an error.

After a write, reads may or may not see it. A best effort approach is taken.

This approach is seen in systems such as memcached. Weak consistency works well in real time use cases such as VoIP, video chat, and realtime multiplayer games. For example, if you are on a phone call and lose reception for a few seconds, when you regain connection you do not hear what was spoken during connection loss.

After a write, reads will eventually see it (typically within milliseconds). Data is replicated asynchronously.

This approach is seen in systems such as DNS and email. Eventual consistency works well in highly available systems.

After a write, reads will see it. Data is replicated synchronously.

This approach is seen in file systems and RDBMSes. Strong consistency works well in systems that need transactions.

• Transactions across data centers

There are two complementary patterns to support high availability: fail-over and replication.

With active-passive fail-over, heartbeats are sent between the active and the passive server on standby. If the heartbeat is interrupted, the passive server takes over the active's IP address and resumes service.

The length of downtime is determined by whether the passive server is already running in 'hot' standby or whether it needs to start up from 'cold' standby. Only the active server handles traffic.

Active-passive failover can also be referred to as master-slave failover.

In active-active, both servers are managing traffic, spreading the load between them.

If the servers are public-facing, the DNS would need to know about the public IPs of both servers. If the servers are internal-facing, application logic would need to know about both servers.

Active-active failover can also be referred to as master-master failover.

• Fail-over adds more hardware and additional complexity.
• There is a potential for loss of data if the active system fails before any newly written data can be replicated to the passive.

This topic is further discussed in the Database section:

• Master-slave replication
• Master-master replication

Availability is often quantified by uptime (or downtime) as a percentage of time the service is available. Availability is generally measured in number of 9s--a service with 99.99% availability is described as having four 9s.

If a service consists of multiple components prone to failure, the service's overall availability depends on whether the components are in sequence or in parallel.

Overall availability decreases when two components with availability < 100% are in sequence:

Availability (Total) = Availability (Foo) * Availability (Bar)

If both Foo and Bar each had 99.9% availability, their total availability in sequence would be 99.8%.

Overall availability increases when two components with availability < 100% are in parallel:

Availability (Total) = 1 - (1 - Availability (Foo)) * (1 - Availability (Bar))

If both Foo and Bar each had 99.9% availability, their total availability in parallel would be 99.9999%.

Source: DNS security presentation

A Domain Name System (DNS) translates a domain name such as www.example.com to an IP address.

DNS is hierarchical, with a few authoritative servers at the top level. Your router or ISP provides information about which DNS server(s) to contact when doing a lookup. Lower level DNS servers cache mappings, which could become stale due to DNS propagation delays. DNS results can also be cached by your browser or OS for a certain period of time, determined by the time to live (TTL).

• NS record (name server) - Specifies the DNS servers for your domain/subdomain.
• MX record (mail exchange) - Specifies the mail servers for accepting messages.
• A record (address) - Points a name to an IP address.
• CNAME (canonical) - Points a name to another name or CNAME (example.com to www.example.com) or to an A record.

Services such as