# Performance vs Scalability: Fast for One User Is Not Enough

> Learn the difference between a system that is fast for one task and a system that stays fast as the crowd grows, and how to tell which problem you have.

**In short:** Performance is how fast a system is for one task, while scalability is whether it stays fast as the crowd grows, and they are different problems.

From "System design", a free course by Venkat R. Murty: https://designervenkat.online/learn/system-design/performance-vs-scalability

## What you will learn

Performance and scalability are two words you will hear again and again in system design. They sound alike, but they answer different questions. In this lesson you will learn what each word means, a simple test to tell which problem you have, and why the two goals sometimes pull against each other. A worked example about a ticket-booking site shows the idea in action.

- **System:** A service made of software and hardware that receives requests and sends back answers, such as a website.
- **Request:** One action sent to a system, such as asking for a web page or a seat map.
- **Performance:** How fast a system handles one request or task at a given load.
- **Scalability:** How well a system keeps its speed and quality when the load or data grows, by adding resources.
- **Load:** The amount of work arriving at a system, such as how many people use it at the same time.
- **Resource:** Anything a system uses to do work, such as a server, memory, or a database.
- **Latency:** The time one request takes from start to finish. A full lesson on it comes later.
- **Throughput:** How many requests a system finishes in a set time, such as per second. A full lesson on it comes later.
- **Bottleneck:** The one part of a system that limits how much the whole system can do.
- **Scale out:** Add more machines so they share the work.

## What does performance mean?

Performance is about how quickly a system handles a single request. Think of opening a page and seeing it appear in a blink. That is good performance. <cite index="3-6">How quickly your system answers requests is what performance measures.</cite> <cite index="9-3">Performance answers one fundamental question: how fast can your system respond to a request?</cite>

Performance is measured at a given load. If the load changes, the speed of one request can change too. So when you talk about performance, say what load you are testing with, such as one user or a few hundred.

### How do teams improve performance?

Speed problems on one request are usually fixed inside the code and setup of that service. The team looks at the work each request does and removes what is not needed.

- **Better methods:** Pick an algorithm, which is a set of steps for solving a problem, that does less work for the same result.
- **Better database queries:** Ask the database for only the rows and columns the page needs, in a form it can find quickly.
- **Less waiting on the network:** Send less data and cut trips between machines, because each trip takes time.

## What does scalability mean?

Scalability asks what happens when more people or more data arrive. <cite index="3-8">A system's capacity to take on more load by adding resources is what scalability describes.</cite> A system that scales well keeps its speed and quality when the crowd gets bigger, instead of falling over. <cite index="9-7">A scalable system should still perform when traffic doubles, and when it grows to ten times the size.</cite>

Growth can mean more users, more requests, or bigger data. <cite index="12-3">Increasing performance can mean serving more units of work, or handling larger units of work, such as when datasets grow.</cite>

### What is the proportional test?

A helpful way to judge scalability is to ask what you get for each new server. <cite index="11-3">A service can be called scalable when its performance rises in proportion to the resources added to it.</cite> In plain words, if two servers handle about twice the load of one, the design is growing the way it should.

- **Grows in proportion:** Each new server adds a similar amount of handled load. Doubling the servers roughly doubles what the system can take.
- **Hits a ceiling:** Extra servers stop helping after a point, because one shared part, such as a single database, is already full.
- **Degrades sharply:** Speed drops quickly once the crowd passes a certain size, even if extra servers are added.

Scalability and speed are separate. A design can be slow at every load and still gain proportionally from added resources. A slow system that scales is still a problem, but it is a different problem from a fast system that cannot grow.

## Diagnosing the problem: performance or scalability?

When a system feels slow, the first job is to find out who feels the slowness and when. 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. This simple test is the starting point for almost every diagnosis.

- **Slow for one user:** This points to a performance problem. The work for one request is already too heavy, so more servers will not fix it on their own.
- **Fast for one user, slow under load:** This points to a scalability problem. One request is fine alone, but the shared parts of the system cannot keep up when many requests arrive together.
- **Slow for everyone at every load:** This can be both problems at once. Check the single-user speed first, then test with more people.

The two problems are fixed in different ways. Performance problems are often tackled by optimizing existing code and infrastructure, while scalability problems are often tackled by changing the architecture to distribute load.

> **Tip:** Fix the slow single request first. A system that takes five seconds for one user will be even slower for a crowd, and the real limit stays hidden until the basics are fast.

## Check your understanding

**Quick check:** A photo-sharing app takes 5 seconds to load a feed even when only 10 people are using it. Adding more servers does not change that. Is this mainly a performance problem or a scalability problem?

A. A scalability problem, because 10 users is already too many for one server
B. A performance problem, because the feed is slow even with very few users, and extra servers do not help
C. A scalability problem, because the app will be slow once it has millions of users
D. Neither, because 5 seconds is a normal time for a photo feed

**Answer:** B. The feed is slow with only 10 users, so the single request is already too heavy. That is a performance problem. Adding servers does not help because the work itself is slow, not because the crowd is too big.

## Why can the two goals pull apart?

Chasing peak speed and chasing growth can conflict. A design that is fastest for one job is often built around one strong machine. A design that grows well is often split across many machines. Each choice has a cost, so you need to decide which goal matters more for your product.

### Peak speed on one machine

The catch is that the machine has a hard upper limit. When a system can only be scaled as a single unit, every hot component drags the cold ones along with it. Once that one machine is full, growth means a redesign.

### The overhead of scaling out

Splitting work across many machines adds steps. A request may travel from one service to another over the network, and each trip takes time. A system can scale horizontally across multiple servers and still feel slow if each request waits on inefficient database queries. So a system built to grow can still feel slower to one user, even while it handles many more users in total.

Good designers accept this cost on purpose. If scalability is critical for accommodating future growth and expanding user base, prioritize scalability-oriented design principles.

## Worked example: a ticket sale

Imagine a concert ticket-booking site. We will look at two moments: a quiet test with one tester, and the day tickets go on sale. This example is a teaching case, not a measured site.

1. **Test one user:** One tester opens the seat map and it loads in 200 ms. That is quick, so performance for a single user is good.
2. **Check the single-user result:** Because one user gets a fast answer, the code for one request is not the main problem. The work for one request is light.
3. **Add the crowd:** When the concert goes on sale, 100,000 fans arrive at the same moment. The seat map crawls, or the site crashes.
4. **Find the shared part:** Every request goes through one server and one database. That shared path is the bottleneck, so the load piles up there.
5. **Name the problem:** The site is fast for one user but poor under heavy load. That is a scalability problem. A fix would spread the requests across several servers and databases, which later lessons explain.

> **Tip:** Ask what happens when one person does the same action, then ask what happens when thousands do it together. The gap between those two answers tells you which problem you have.

## A small model of a ceiling

The program below is a made-up model, not real measurements. Each server can handle 100 requests per second. All servers share one database that can handle at most 250 requests per second. Watch what happens as we add servers.

```python
def handled(servers):
    app_limit = servers * 100
    db_limit = 250
    return min(app_limit, db_limit)

for n in [1, 2, 3, 4]:
    print(f"{n} servers handle {handled(n)} requests per second")
```

Output:

```text
1 servers handle 100 requests per second
2 servers handle 200 requests per second
3 servers handle 250 requests per second
4 servers handle 250 requests per second

```

The first two servers add capacity in proportion. The third adds only a little, and the fourth adds nothing, because the shared database is the ceiling. Adding servers helps only until you reach the bottleneck.

## Apply the idea

**Quick check:** A checkout page takes 80 ms for one shopper. On a busy holiday, it takes 20 seconds. The team has six web servers, and the shared database is at its limit. They add ten more web servers and nothing improves. What should they look at first?

A. Buy faster hardware for the web servers, because each one must be slow on its own
B. Look at the shared database, since the page is fast for one shopper but the shared part is full
C. Rewrite the page code to cut the 80 ms, because that is the scalability problem
D. Do nothing, because 20 seconds is expected on a busy holiday

**Answer:** B. One shopper gets a fast page, so the single request is fine. The shared database is full, and extra web servers cannot help while it stays full. That points to a scalability ceiling at the shared part.

## Key points to remember

- **Performance:** Speed of one request at a given load. If one user is slow, you have a performance problem.
- **Scalability:** Keeping speed and quality as load grows by adding resources. If one user is fast but a crowd is slow, you have a scalability problem.
- **The trade-off:** A single strong machine can be very fast but hard to grow. Many machines grow well but add steps that can slow each request.

Next, you can explore how latency and throughput are measured, and the tools that help a system grow, such as caches and load balancers. Each has its own lesson.

## Sources

- [Performance vs scalability, System Design Primer (Donne Martin, via Mintlify)](https://www.mintlify.com/donnemartin/system-design-primer/topics/performance-vs-scalability)
- [Performance vs Scalability in System Design, Grokking the System Design blog](https://grokkingthesystemdesign.com/blog/performance-vs-scalability-system-design/)
- [Design for Scalability, Software Design Principles](https://design-principles.info/principles/scalability/)
- [What Is Scalability, Learning Module (onenoughtone)](https://www.onenoughtone.com/learning-path/system-design-hld/learning/what-is-scalability/2)
- [What Software Scalability Actually Means, Dokploy blog](https://dokploy.com/blog/software-scalability)
- [Scalability v.s. Performance, Vahid blog](https://vahid.blog/post/2021-07-02-scalability-vs-performance/)
- [Performance vs scalability, Rajaram Joshi (LinkedIn)](https://www.linkedin.com/pulse/performance-vs-scalability-rajaram-joshi)
