Introduction to System Design: What It Is and Why It Matters
A plain guide to what system design means, the common parts it uses, and the qualities a good design must balance.
In short
System design means planning the parts of a software system and the qualities it must balance, such as how it handles growth.
11 min readFree
What you will learn
This lesson is the first step in system design. You will learn what the phrase means, what a designer decides, and which words you will meet again and again. You do not need any design experience to follow along.
By the end, you should be able to describe a simple system in plain words, name three common building blocks, and explain why every design involves trade-offs.
Key words
- System
- A group of parts that work together to do a job. A shop website with a checkout step is a system.
- Design
- A plan that decides which parts exist and how they work together.
- Architecture
- The big-picture layout of a system: its main parts and the links between them.
- Component
- One part of a system, such as a server, a database or a cache.
- Requirement
- Something the system must do, or a quality it must reach.
- Trade-off
- Giving up one good quality to get another good quality.
What does system design mean?
System design is the work of planning a software system before or while you build it. A designer picks the pieces a product needs. For each piece, the designer also writes down its job, how it talks to the other pieces, and the path that data takes through the whole system.
A restaurant is a useful picture. It needs a kitchen, tables, a cash desk and a way for orders to reach the cook. Someone has to decide each of these before the doors open. System design asks the same kind of question about software.
The goal is to meet the system's requirements. A design that looks neat on paper still fails if it cannot handle real use, so a designer checks the plan against the needs of the people who will use it.
Many sources describe the same core idea in different words. The plan covers components, their interfaces, the data they handle, and how they interact. Good sources also stress that a design must hold up when things go wrong.
Writing code and designing a system are different skills. Code answers how one piece works inside. A design answers how many pieces work together when many people use them at the same time.
Design is also a team activity. Architects, engineers and product managers often share the work and the decisions.
Why does it matter?
Good design makes software easier to grow, fix and trust. A poor design can work fine for ten users and then fail at ten thousand. Designers try to see that risk before it happens.
System design is also a common topic in job interviews. Many mid-level and senior software jobs include a design round, where the candidate talks through how they would build a large system. Learning the basics early helps with both work and interviews.
Why start with requirements?
Every design starts with a clear list of what is wanted. Designers split this list into two groups. Both groups matter, and mixing them up is a common beginner error.
Functional requirements
What the system should do. For a shop, one example is: a shopper can add an item to a cart and pay for it.
Non-functional requirements
How well the system should do it. Speed, uptime, safety and the ability to grow all belong here.
Constraints
Limits you cannot change, such as a budget, a legal rule or the tools your team already uses.
Non-functional requirements are often the hard part. Two designs can do the same job, yet one may be slow or may crash under a crowd. You need numbers to tell them apart.
Tip
Turn vague words into checkable numbers. 'Fast' is hard to test. 'Average search takes less than 100 milliseconds' can be measured, and the team can agree on it.
What are the common building blocks?
Most designs reuse a small set of parts. You do not need to master them yet. For now, learn what each one is for and how they connect.
Load balancer
A traffic director. It spreads incoming requests across several servers, so one server does not become a bottleneck. It can also check which servers are healthy and skip the broken ones.
Cache
A fast store, usually kept in memory, that holds copies of data people ask for often. Reading from the cache saves the slower trip to the database.
Database
The place where data is kept safely over time, so it survives restarts and can be searched later.
A common starting pattern is easy to picture. Clients, such as phones and web browsers, send requests to a load balancer. The load balancer passes each request to an app server. The app server reads from a cache first, and the cache is backed by a database.
Each piece has a cost. A cache is quick, but its copy can be out of date. A database is reliable, but a single one can become slow when many people ask at once.
How do you scale to handle growth?
Scalability is a system's ability to handle more users, more requests or more data without a full redesign. Designers ask early how the system will behave when traffic grows ten times.
Scaling is usually done in one of two ways. Each way has its own price.
Scaling up and scaling out are two different choices. Here is the plain difference between them.
Vertical scaling (scaling up)
Give one machine more power, such as more memory or a faster processor. It is simple, but one machine has a limit.
Horizontal scaling (scaling out)
Add more identical machines behind a load balancer. It can grow further, but the software must be built to work this way.
Horizontal scaling needs stateless services. A stateless service keeps no user-specific data on its own machine. Any server can handle any request, because shared data lives in an outside store, such as a database or cache.
Tip
Ask whether a server remembers anything about a user between requests. If it does, adding more servers will not help until that memory moves to shared storage.
What qualities must a design balance?
Many designers look at four recurring concerns: scalability, availability, latency and consistency. Each one is a quality the system can have more or less of.
Scalability
The system keeps working well as load grows.
Availability
The share of time the system can be used. A system that is down often has low availability.
Latency
How long one request takes to get its reply. Users feel high latency as a slow page.
Consistency
Whether copies of the same data agree. When one user changes data, others should soon see the same answer.
You cannot maximize all four at once without cost. The next sub-topic shows how teams put numbers on the first two.
How do you measure quality with SLIs and SLOs?
Google's site reliability engineers use two terms that help. An SLI, or service level indicator, is a careful measure of one part of a service, such as request latency or the error rate. An SLO, or service level objective, is the target value that an SLI should reach.
Request latency is the time it takes to return a response to a request. Availability is the fraction of time a service is usable. Many teams measure availability as the share of requests that succeed.
Perfect availability is not realistic. Near-perfect availability is often possible. Teams often describe it with nines, so 99.9% is called three nines and 99.99% is called four nines.
A target of 99.99% allows about 52.56 minutes of downtime in a year. The short program below checks that number.
minutes_per_year = 365 * 24 * 60
target = 0.9999
downtime = minutes_per_year * (1 - target)
print(f'{downtime:.2f}')Output
52.56
Tip
When someone says 'the service should be reliable', ask for the SLI and the SLO. A single number turns a wish into a goal the team can check.
Why is no design best at everything?
There is rarely one design that is best at every quality. A large part of the work is deciding which qualities matter most for your system, and then explaining why you chose that path.
Caching is a good example. A cache makes reads faster, but its copy may be stale. Some caching styles are faster but riskier, because data can be lost if the cache fails before the database receives it. The designer must choose which risk the users can accept.
Quick check
Which statement describes a trade-off?
How do you start a design?
Beginners often jump straight to tools. A calmer order helps. The steps below give a simple path from the idea to a first plan. Real teams repeat these steps as they learn more.
- 1
Clarify the requirements
Write down what the system must do, and how well it must do it. Note any limits, such as budget or legal rules.
- 2
Estimate the load
Guess how many requests arrive each second, which is often called QPS, and how much data must be stored. These numbers shape almost every later choice.
- 3
Sketch the main parts
Draw the clients, the load balancer, the app servers, the cache and the database. Show the arrows for data flow.
- 4
Scale the busiest part
Find the part that will crack first. Add servers, a cache or a copy of the database where the load is highest.
- 5
Check failures and trade-offs
Ask what happens when one part fails or becomes slow. Write down what you chose to give up and why.
Designers often start with a basic version and improve it. They measure how it behaves, then change the parts that cause trouble.
Tip
Keep a short written list of assumptions. If a guess about traffic is wrong, the list shows you which parts of the design to revisit.
A small example in code
The sample below shows the simplest idea behind a load balancer. It sends each request to the next server in a list, then starts again at the top. This method is called round robin. It is a toy example, not a real product.
servers = ['server-a', 'server-b', 'server-c']
requests = ['req-1', 'req-2', 'req-3', 'req-4', 'req-5']
for i, req in enumerate(requests):
target = servers[i % len(servers)]
print(req, '->', target)Output
req-1 -> server-a req-2 -> server-b req-3 -> server-c req-4 -> server-a req-5 -> server-b
The percent sign gives the remainder after division. It makes the list wrap around, so the fourth request returns to the first server.
Quick check
Why does horizontal scaling need stateless services?
Common beginner mistakes
Choosing tools too early
Picking a cache or a message queue before stating the requirements. The tool may solve a problem you do not have.
Skipping the numbers
Designing without estimating traffic or data size. Without numbers, you cannot tell whether a part will cope.
Planning only the happy path
Designing for the case where everything works. A useful design also says how the system responds when a part fails or slows down.
Tip
Say your assumptions out loud, or write them down. Teammates and interviewers can then correct a wrong guess early, before it shapes the whole design.
Summary
System design is the planning of the parts of a system, what each part does, how the parts communicate, and how data moves between them. It starts with clear requirements, both what the system does and how well it does it.
Common building blocks include load balancers, caches and databases. Growth can be handled by scaling up or scaling out. Quality is judged by scalability, availability, latency and consistency, and measured with SLIs and SLOs.
Every design involves trade-offs. Your job is to choose which qualities matter most, explain the choice, and say what happens when something goes wrong.
Sources
- What is System Design? (AlgoMaster)
- Google SRE book: Service Level Objectives
- Google SRE book: Embracing Risk
- Introduction to System Design (Prachub)
- System Design Introduction (DEV Community)
- Introduction to Modern System Design (Educative)
- System Design Primer: From Principles to Production (GitDoc)
- System Design Primer (System Design School)
- System Design Scalability Patterns (eStudy247)
- System Design Primer: Step-by-Step Guide (Grokking the System Design)
- What Is System Design? A Complete Guide for Developers (VickyBytes)
- System Design Introduction (GeeksforGeeks)
Last updated on 17 November 2026
Related lessons
Learn with me
Every lesson is free. I add new ones as I learn. Have a question, or want help with your own work? Book a short call.