Server Request Capacity Calculator (Little's Law)
Solve Little's Law (L = λW) for arrival rate, response time, or concurrency — enter any two and calculate the third. Also estimates per-instance utilization, instances needed for a target throughput, and utilization at other traffic levels.
Input
Pick the two values you already know — the third is calculated with Little's Law.
Requests arriving per second.
Average time to fully handle one request, in milliseconds.
Requests per second one server/instance can sustain (from load testing, or thread-pool size ÷ response time).
Optional — the traffic level to provision for. Leave blank to use the arrival rate above.
Output
| Metric | Value |
|---|---|
| No data yet | |
| Traffic Level | Throughput (req/s) | Utilization |
|---|---|---|
| No data yet | ||
Guides
Capacity planning questions — "how many concurrent requests will this get?", "how many instances do I need?" — usually get answered with a guess. Little's Law turns them into an exact number: it's a proven relationship between arrival rate, response time, and concurrency that holds for any stable system processing requests, from a single API server to an entire fleet.
How it works
Little's Law states L = λW: average concurrency (L) equals the arrival rate (λ) times the average time each request spends in the system (W). Any two of those values determine the third — pick which two you know and this calculator solves for the missing one, showing every step.
On top of the base formula, enter a per-instance capacity (μ) — the requests per second one server or worker can sustain — and the calculator adds:
- Utilization at your current load — λ ÷ μ, plus the instance count needed to keep each one under 100% (
ceil(utilization)). - Instances needed for a target throughput — the traffic level you're provisioning for, so you can size before you scale.
- Utilization at other traffic levels — 50% to 200% of your target, using the instance count sized for that target, so you can see the safety margin (or lack of one) before traffic actually spikes.
Finding your per-instance capacity (μ)
If you've load-tested the service, use the measured sustained requests/second directly. Otherwise estimate it from response time: a single-threaded worker handling one request at a time sustains roughly 1 ÷ W req/s, and a worker pool of size N sustains roughly N ÷ W. This is the same blocking-coefficient idea the Thread Pool Size Calculator uses to size N in the first place.
How to use it
- Pick which two of Arrival Rate, Response Time, and Concurrency you already know.
- Enter those two values — the calculator solves for the third and shows the formula and steps used.
- Set Per-Instance Capacity to what one server can sustain, and optionally a Target Throughput to plan for.
- Read utilization and instance counts in the results table, and the scaling table for how utilization shifts as traffic moves away from your target.
Is this the same as an M/M/1 queueing model?
No — Little's Law makes no assumption about arrival or service-time distributions, so it's more broadly applicable but doesn't predict queueing delay or tail latency the way an M/M/1 or M/M/c model does. It tells you the average concurrency and utilization exactly; for percentile latency under load, you'd need a full queueing or simulation model.
What if I'm converting a stated API rate limit instead?
Use the Rate Limit Calculator to turn a quoted limit ("300 requests per 15 minutes") into per-request pacing and multi-worker delays — a different starting point than measuring your own live arrival rate and response time.
Privacy
Everything runs in your browser — nothing you enter is sent anywhere.
Use it from code
From 3 credits per callREST API
curl -X POST https://api.iotools.cloud/v1/tool/server-capacity-calculator \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"knownPair": "rw",
"arrivalRate": "50",
"responseTime": "200",
"concurrency": "10",
"perInstanceCapacity": "20",
"targetThroughput": "75"
}'Swap in your own key from your account. The tool's fields are the body — no wrapper.
Ask an AI agent
Use the IOTools `server-capacity-calculator` tool (Server Request Capacity Calculator (Little's Law)) on this input:
YOUR_INPUT_HEREPaste this at any agent connected to the IOTools MCP server, then add your input.