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.

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.

9 min readFree

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.

Key words

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?

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

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?

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

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.