Cloud Explainers

Why One Linux Server Handles More Users Than You Think

Linux8 min videoPublished Nov 16, 2026

Users are not requests: 10,000 visitors a day is about 12 requests a second at the busiest minute. On one Linux server cut to one CPU core and 1 GB of memory we measure it for real: 94,475 page requests a second from nginx, 8,170 from a Python app with a database, 5,000 idle connections for 20 MB, what full looks like (slower answers, not errors), a missing index taking the app to 212 a second, and a server that is full while its core is 2% busy, because its workers are waiting.

One core, a flood of requests

You probably think ten thousand users need a cluster of servers: a load balancer and a row of machines. A farmers market's order-ahead site runs on one Linux server instead, cut down to one CPU core and one gigabyte of memory.

What you picture for 10,000 users: diagram of 10,000 users, Load balancer, Server 1, Server 2, Server 3, A cluster

nproc counts its cores: one. wrk, a load tester on Ana's laptop, asks for the market's page as fast as it can for ten seconds, over fifty connections at once. Over ninety-four thousand requests a second, from one core. Later, we'll fill it up while its core sits almost idle.

Ana: laptop, then market server
nproc1
Ana: laptop, then market server
wrk -t2 -c50 -d10s http://market/Running 10s test @ http://market/
  2 threads and 50 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency   530.07us  110.10us  12.21ms   98.76%
    Req/Sec    47.47k     2.71k   51.06k    79.50%
  944804 requests in 10.00s, 1.46GB read
Requests/sec:  94474.56
Transfer/sec:    149.38MB

Users are not requests

Why does that sound wrong? Because users and requests are different things. Say ten thousand people visit in a day, and each visit asks the server ten times. That's a hundred thousand requests, spread over the eighty-six thousand four hundred seconds in a day: about one point two a second. Even if your busiest minute runs ten times the average, that's about twelve a second, for a core that just answered thousands. And users online right now aren't requests either: someone reading the market's stalls for a minute sends nothing during that minute.

10,000 visitors a day: about 12 requests a second: diagram of 10,000 visitors, 100,000 requests, 86,400 seconds, 1.2 a second, 12 a second, Market server

Think of a supermarket. Hundreds of shoppers are inside, but most of them are walking the aisles. Only the few at the till need the cashier. The server's core is the cashier. A visitor reading a page is a shopper in the aisles: they cost it almost nothing. Only requests, the moments at the till, take its time.

Shoppers and the cashier: comparison table of In the supermarket vs On the server, Everyone, Most of them, The busy part, Just browsing

Real code, same core

But that page was one file nginx, the web server, just sends. Real sites run code. Here, nginx passes every request for the market's app to Python, which reads the stalls' products from a database, each time. Guess first: how many a second does the same core manage now? About eight thousand, each answered in one point two milliseconds. About twelve times fewer than the page, because nginx copies a file it already has, while the app runs Python and asks the database every time. Still, that's hundreds of times what ten thousand visitors need.

Ana's laptop: the load tester
wrk -t2 -c10 -d10s http://market/api/stallsRunning 10s test @ http://market/api/stalls
  2 threads and 10 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency     1.23ms  408.76us  14.67ms   86.73%
    Req/Sec     4.11k   163.44     4.24k    97.00%
  81740 requests in 10.01s, 210.63MB read
Requests/sec:   8169.76
Transfer/sec:     21.05MB

Open tabs cost almost nothing

And people who just have the market's page open? On the server, memused, a small script that reads its memory, says: ninety-six megabytes. Then the laptop opens five thousand connections, loads the page on each, and leaves them open and idle for forty seconds, like five thousand browser tabs. ss, which lists network connections, counts them on the server: five thousand, established. Memory now: a hundred and sixteen. Twenty megabytes for five thousand open tabs: about four kilobytes each. Shoppers in the aisles.

Ana: laptop, then market server
memusedMemory in use: 96 MB of 1024 MB
Ana: laptop, then market server
python3 idle.py 5000 405000 connections open, page loaded on each, now idle for 40 s
Ana: laptop, then market server
ss -sTotal: 5045
TCP:   24788 (estab 5000, closed 19785, orphaned 0, timewait 14759)

Transport Total     IP        IPv6
RAW	  0         0         0
UDP	  1         1         0
TCP	  5003      5003      0
INET	  5004      5004      0
FRAG	  0         0         0
Ana: laptop, then market server
memusedMemory in use: 116 MB of 1024 MB

When it's full, a line forms

So what does full look like? Ana points four hundred connections at the market's app, each asking again the moment it gets an answer. On the server, cpuused reads how busy its core is: a hundred percent. Requests a second: about eight thousand, the same as with ten connections. But each answer now takes forty-nine milliseconds, instead of one point two.

Ana: laptop, then market server
wrk -t2 -c400 -d10s http://market/api/stallsRunning 10s test @ http://market/api/stalls
  2 threads and 400 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency    48.68ms    3.23ms  83.34ms   77.83%
    Req/Sec     4.12k   205.67     4.58k    86.50%
  82230 requests in 10.06s, 211.89MB read
Requests/sec:   8177.08
Transfer/sec:     21.07MB
Ana: laptop, then market server
cpuused 3CPU busy: 100% of 1 core over the last 3 s

Back at the supermarket: a longer line doesn't make the cashier scan faster. Past the limit, more requests don't get served faster. They wait. So a full server rarely shows up as errors first. It shows up as answers getting slower.

Same core, longer line: ms per answer: chart of 10 connections: 1.23 ms, 400 connections: 48.7 ms, Both: about 8,000 requests a second

There's a simple rule hiding in those numbers. The wait is the line divided by the rate. Four hundred requests in line, served at about eight thousand two hundred a second: forty-nine thousandths of a second each. Just what wrk measured. So when the rate stays flat and the answers slow down, the line is longer than the core can clear.

Wait = line ÷ rate: diagram of 400 in line, 8,177 a second, 48.9 ms

The slowest step sets the limit

So is the core always the limit? Usually, the limit is the slowest thing a request does. The app's past-orders page looks up one customer's orders: about two hundred and twelve a second. Why so few? On the server, SQLite's query plan, how the database will find the rows, says this about the lookup: scan orders. To find one customer, it reads all five hundred thousand orders. And this table grows every market day, so the lookup gets slower every week, without a single extra visitor.

Ana: laptop, then market server
wrk -t2 -c20 -d10s "http://market/api/orders?customer=1234"Running 10s test @ http://market/api/orders?customer=1234
  2 threads and 20 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency    93.93ms    5.20ms 138.33ms   75.44%
    Req/Sec   106.29      9.17   121.00     78.79%
  2125 requests in 10.03s, 1.28MB read
Requests/sec:    211.92
Transfer/sec:    131.21KB
Ana: laptop, then market server
sqlite3 market.db "EXPLAIN QUERY PLAN SELECT * FROM orders WHERE customer_id = 1234"QUERY PLAN
`--SCAN orders

An index is a sorted list of one column, pointing at the rows. Without it, every lookup walks the whole table. With it, the database jumps straight to that customer's few orders.

Scan vs index: comparison table of No index: SCAN vs Index: SEARCH, To find one customer, Rows read

Ana adds one index on the customer column. It takes a fraction of a second. Now the plan says search, using the index. Guess first: how many lookups a second now? Over ten thousand. About fifty times more, from one line, on the same core.

Ana: laptop, then market server
time sqlite3 market.db "CREATE INDEX orders_by_customer ON orders(customer_id)"real	0m0.154s
user	0m0.081s
sys	0m0.006s
Ana: laptop, then market server
sqlite3 market.db "EXPLAIN QUERY PLAN SELECT * FROM orders WHERE customer_id = 1234"QUERY PLAN
`--SEARCH orders USING INDEX orders_by_customer (customer_id=?)
Ana: laptop, then market server
wrk -t2 -c20 -d10s "http://market/api/orders?customer=1234"Running 10s test @ http://market/api/orders?customer=1234
  2 threads and 20 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency     1.91ms  538.59us  22.85ms   88.71%
    Req/Sec     5.29k   223.77     5.54k    96.50%
  105296 requests in 10.01s, 63.66MB read
Requests/sec:  10523.17
Transfer/sec:      6.36MB

Full, with the core asleep

Now the checkout. To take a payment, the app asks a card payment service, which answers in about two hundred milliseconds, like a real card processor. Fifty shoppers check out at once. And the core? Busy two percent of the time. Checkouts: fourteen a second. Each waits almost three seconds. This is the full server whose core is asleep.

Ana: laptop, then market server
wrk -t2 -c50 -d10s --timeout 30s -s post.lua http://market/api/checkoutRunning 10s test @ http://market/api/checkout
  2 threads and 50 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency     2.96s   987.35ms   3.65s    80.71%
    Req/Sec     7.38      4.30    29.00     80.95%
  140 requests in 10.02s, 24.20KB read
Requests/sec:     13.97
Transfer/sec:      2.42KB
Ana: laptop, then market server
cpuused 3CPU busy: 2% of 1 core over the last 3 s

Why? The app runs three workers, and each handles one request at a time. While a worker waits for the card service, it does nothing else. Three workers, two hundred milliseconds each: at most fifteen a second, however idle the core is. Three cashiers, each on the phone to the bank.

Three workers, all waiting: diagram of Checkouts, Worker 1, Worker 2, Worker 3, Card service, Market server: 1 core

gunicorn, the program that runs these workers, says it on its own design page: workers are not clients. A handful of workers handles heavy traffic. Its starting formula, two per core plus one, gives three, for this server's single core. For waiting, the same page offers threads: one worker, many requests waiting side by side.

Full, with the core asleep: browser screenshot of 1 core: 3 workers

So one setting changes, in the service file that tells Linux how to run the app: threads, twenty-five per worker. That's seventy-five checkouts that can wait at the same time.

One setting: threads to wait on: code change of /etc/systemd/system/market.service, ExecStart=gunicorn --workers 3 --threads 25 -b 127.0.0.1:8000 app:app (3 workers × 25 threads = 75 waiting at once)

Ana reloads that file and restarts the app, and the same fifty checkouts: a hundred and eighty a second, each in about a quarter of a second. Same core. Same memory. Threads help when a request waits. When it's busy computing, only more core time helps.

Ana: laptop, then market server
sudo systemctl daemon-reload && sudo systemctl restart market
Ana: laptop, then market server
wrk -t2 -c50 -d10s --timeout 30s -s post.lua http://market/api/checkoutRunning 10s test @ http://market/api/checkout
  2 threads and 50 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency   271.93ms   98.14ms 603.45ms   77.80%
    Req/Sec    94.53     35.88   213.00     85.42%
  1812 requests in 10.08s, 313.21KB read
Requests/sec:    179.72
Transfer/sec:     31.07KB

So how many users?

So how many visitors could one core serve the market? Take the app's measured eight thousand a second, Python and database included. With ten requests a visit, and a busiest minute ten times the average, that's about seven point one million visits a day. Our core is a fast laptop core, and a cheap cloud core is often slower. If yours manages a quarter of this, that's still about one point eight million.

One core, in visitors a day: diagram of 8,170 requests a second, ÷ 10 requests a visit, ÷ 10 for the busiest minute, = 7.1 million visits a day, A quarter as fast: 1.8 million

Here's everything this one core did. The numbers that fell weren't the core's fault: a missing index that forced a scan, and workers stuck waiting. So before you buy a bigger server, measure with a load tester, and fix the slowest step first.

What one core served, per second: chart of The page (nginx): 94475 a second, The app (Python): 8170 a second, Orders, no index: 212 a second, Orders, index: 10523 a second, Checkout, waiting: 14 a second, Checkout, threads: 180 a second

When you do need more

So when does the market need more than one server? When its one core stays busy all day even after the fixes, and answers keep slowing. When the site can't be down: a second server is there for when the first one fails, for safety, not speed. And when the data no longer fits in one machine's memory or storage.

When one server isn't enough: cards of Full after the fixes, It can't be down, The data won't fit

Recap

So: count requests, not users. Idle visitors cost almost nothing. A full server answers slower, and the limit is usually the slowest step: a scan of a whole table, or a wait on another service.

One server: four things to remember: diagram of Count requests, not users, Idle visitors are cheap, Full means slower answers, Fix the slowest step

If this saved you from planning a cluster too soon, a like helps YouTube show this to more beginners, and subscribing brings more real measurements like these.

Every number here came from three real Ubuntu machines in our lab, and every command and the lab files are linked in the description. Thanks for watching Cloud Explainers.

Sources

Demos: three containers on our own Mac standing in for a farmers market's server, a card payment service and Ana's laptop; the market and its customers are made up. Every request and number was measured. Watch the full video on YouTube.

More videos

DevOps & CI/CD9 min

DevOps with Ansible Will Finally Make Sense After This

Networking9 min

How SNMP Network Monitoring Works

Git8 min

How to Fix GitHub 'Permission Denied (publickey)' Errors

PostgreSQL7 min

How to Fix PostgreSQL 'Password Authentication Failed'

Networking7 min

How to Fix Network 'Connection Refused' Errors

DevOps & CI/CD9 min

DevOps Pipelines: Jenkins vs GitHub Actions

Networking11 min

Every Networking Term a Beginner Needs in 12 Minutes

Docker6 min

How to Fix Docker 'Permission Denied' on docker.sock

Git7 min

How to Fix Git 'Updates Were Rejected' When You Push

Linux7 min

How to Fix nginx 502 Bad Gateway Errors on Linux

Linux8 min

How to Fix Linux apt 'Could Not Get Lock' Errors (Ubuntu)

Networking9 min

How Email Works on the Internet (SMTP) in 10 Minutes

Python8 min

The Python Roadmap for Beginners

Go (Golang)21 min

Golang REST API with Gin: Full Tutorial for Beginners

Networking10 min

How a WireGuard VPN Network Works

Linux9 min

Linux Makefiles Will Finally Make Sense After This

Auth (OAuth, JWT)9 min

SAML vs OAuth vs OpenID Connect: What's the Difference?

Python7 min

How to Fix Python cron Jobs That Never Run

Linux22 min

Linux Bash Scripting: Full Tutorial for Beginners

Networking10 min

How PXE Network Boot Works

Active Directory9 min

How Active Directory Works

Linux10 min

How to Fix a Linux systemd Service That Won't Start

Linux9 min

Linux Logs: syslog vs journald

Auth (OAuth, JWT)9 min

JWT vs Session Cookies: Which One Should You Use?

Docker10 min

Docker vs Docker Compose: Which One Should You Use?

Docker9 min

How to Fix Docker Compose Containers That Can't Talk to Each Other

Django (Python web framework)22 min

Django Full Tutorial for Beginners

Linux9 min

How Linux systemd Works

Networking8 min

How to Fix 'Windows Cannot Access' Network Share Errors (SMB)

APIs10 min

REST vs gRPC: Which One Should You Use?

Certificates & PKI (ADCS)9 min

How to Fix SSL Certificate Chain Errors (Missing Intermediate)

Python9 min

Every Python Concept for Beginners in 10 Minutes

Databases & SQL9 min

Every SQL Join Type in 10 Minutes

OpenRouter (one API for many AI models)9 min

Why OpenRouter Free Models Hit Their Limit So Fast

Gemini API & Google AI Studio9 min

Why Your Gemini API Free Tier Runs Out So Fast

OpenRouter (one API for many AI models)10 min

OpenRouter Will Finally Make Sense After This

Caching & Redis10 min

How Redis Caching Works

Gemini API & Google AI Studio10 min

Gemini API vs Vertex AI: Which One Should You Use?

Gemini API & Google AI Studio8 min

How to Fix a Leaked Gemini API Key

Go (Golang)9 min

Why Golang Uses Goroutines Instead of Threads

Gemini API & Google AI Studio9 min

How to Fix Gemini API Error 429: Resource Exhausted

Claude & the Claude Developer Platform10 min

Claude Token Pricing Will Finally Make Sense After This

Python11 min

Why Python Web Scraping Returns Nothing (and the Fix)

Python10 min

Python uv vs pip: Which One Should You Use?

Python22 min

Python Automation: Full Tutorial for Beginners

Auth (OAuth, JWT)9 min

How OAuth Login Works

Gemini API & Google AI Studio10 min

Google AI Studio Will Finally Make Sense After This

Docker10 min

What Happens When You Run a Docker Container

Claude & the Claude Developer Platform8 min

How to Fix Claude Code Billing Your API Key Instead of Your Plan

Auth (OAuth, JWT)9 min

Why Passkeys Can't Be Phished Like Passwords

PowerShell10 min

PowerShell vs Bash: Which One Should You Learn?

Linux10 min

The Linux Roadmap for Beginners

Django (Python web framework)9 min

Django vs FastAPI: Which One Should You Use?

Databases & SQL10 min

Why SQLite Is the Most Used Database in the World

Databases & SQL11 min

How a NoSQL Database Like MongoDB Works

Python11 min

How to Fix Python pip error: externally-managed-environment

Databases & SQL9 min

How to Fix MySQL Too Many Connections Database Errors

Go (Golang)9 min

Golang Concurrency Will Finally Make Sense After This

AWS10 min

How Amazon S3 Works

Kubernetes10 min

How Kubernetes Works

Git10 min

How Git Works

Docker10 min

How to Fix Docker Port Already Allocated Errors

PostgreSQL10 min

How PostgreSQL Works

Git8 min

How to Fix Git Merge Conflicts

Linux9 min

How to Fix No Space Left on Device in Linux

Networking10 min

How the Internet Works

Databases & SQL9 min

SQL vs NoSQL: When Each One Wins

Auth (OAuth, JWT)8 min

How to Fix JWT Token Expired Errors (401 Unauthorized)

Claude & the Claude Developer Platform9 min

Claude API vs Claude Pro: Why Your Subscription Doesn't Include It

AI agent skills9 min

Why AI Agent Skills Beat Giant Prompts

Linux10 min

Linux Cron Jobs Will Finally Make Sense After This

Cybersecurity10 min

Security Logs Will Finally Make Sense After This

Cybersecurity8 min

How to Fix a Security Leak: An API Key Pushed to GitHub

DNS9 min

DNS Will Finally Make Sense After This

Cybersecurity9 min

Never Ignore a Security Update

Auth (OAuth, JWT)9 min

Two-Factor Authentication Will Finally Make Sense

Networking8 min

Never Expose a Database to the Internet

Cybersecurity10 min

SSH Keys vs Passwords: Which Is Safer for Security?

Linux10 min

The 5 Levels of Linux Boot: From Power On to Login

Networking12 min

The 5 Levels of Network Firewalls

Cybersecurity10 min

Password Security: Why Hackers Crack Weak Passwords

Linux9 min

Why Your Linux Server Runs Out of Memory

Networking10 min

HTTP vs HTTPS: What Actually Changes on Your Network

Linux12 min

Every Linux File Permission You Need to Know

Linux10 min

Linux Processes vs Threads: When Each One Wins

Networking11 min

The OSI Model Will Finally Make Sense After This

Git11 min

The 7 Levels of Git

Networking10 min

Every Network Troubleshooting Command You Need

Cybersecurity10 min

Hashing vs Encryption in Cybersecurity: When Each One Wins

Networking11 min

Why the Internet Ran Out of IP Addresses

Linux11 min

Linux Package Managers: apt vs Snap vs Flatpak

Python9 min

Why Python Is Slow (and When It Doesn't Matter)

Networking11 min

TCP vs UDP: When Each One Wins

Linux8 min

Stop Running Linux as Root (Do This Instead)

Linux11 min

Linux Users and Groups Will Finally Make Sense

Cybersecurity9 min

Why Phishing Beats Good Security (and How to Spot It)

Docker12 min

The 7 Levels of Docker

AI agents & MCP12 min

AI Agents Will Finally Make Sense After This

Git8 min

Stop Using git push --force (Use This Instead)

AI agent skills10 min

Agent Skills vs MCP: When Each One Wins

Networking12 min

Networking Will Finally Make Sense After This

Linux12 min

Every Linux Command You Actually Need

Cybersecurity12 min

The 7 Levels of Cybersecurity

System design12 min

Every System Design Concept You Need, in One Diagram

PostgreSQL10 min

Why PostgreSQL Ignores Your Index