esc
  • WorkflowsPages
  • Case studiesPages
  • Machine Learning FoundationsLearn
  • AI EngineeringLearn
  • AI Guardrails & Red TeamingLearn
  • UI/UXLearn
  • Design SystemsLearn
  • Production System DesignLearn
  • Book a callContact
  • Download ResumeContact
Let’s talk

I’ll build the agent for it.

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.

Python
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. 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. 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. 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. 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. 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.

Python
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

How is this lesson?

Last updated on 17 November 2026

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.