# Concurrency & Throughput Calculator

- **URL:** https://codeasystem.com/calculators/developer/concurrency-throughput-calculator/
- **Category:** developer
- **Description:** Apply Little's law to solve the missing variable among arrival rate, latency and concurrent requests, with capacity guidance.
- **Primary output:** Concurrent requests in system (L = λW): 6

## Inputs
- Arrival rate λ (name: `arrivalRate`, type: number, example: 50)
- Average latency W (name: `latencyMs`, type: number, example: 120)
- Concurrent requests L (name: `concurrency`, type: number, example: leave blank to solve)

## Outputs
- Concurrent requests in system (L = λW): 6
- Arrival rate λ: 50 req/s
- Latency W: 120 ms
- Capacity guidance: A pool below 6 workers queues requests at this traffic level.

## Formula / methodology
```
Little's law: L = λ · W
λ req/s · W seconds · L requests in system
```

Little's law links three averages that must hold in any stable system: the number of requests in flight equals arrival rate times time-in-system. Enter any two values and the third follows algebraically; concurrency from traffic, sustainable throughput from pool size, or implied latency from observed load.

## Assumptions & limitations
- Stable system; arrivals equal completions long-run.
- Averages only; bursts and tails need queueing models.
- W includes queueing plus service time, end-to-end.

## How to use
1. **Fill in any two fields**; Leave exactly the one you want solved blank; the form explains itself otherwise.
2. **Read the guidance row**; Each result translates into a concrete pool-size or headroom statement.

## Example
Traffic arriving at 50 req/s with 120 ms average response keeps, on average, 6 requests in flight; a worker pool below 6 would queue them.

Result for these inputs:

```
Concurrent requests in system (L = λW): 6
```

## About this calculator
### One law, three planning questions

“How many connections will 500 req/s hold open?” Solve L. “What throughput can 20 workers sustain at 200 ms?” Solve λ. “What latency holds given our pool?” Solve W. Same equation, different unknowns; which is why Little’s law anchors capacity reviews everywhere from web farms to database pools.

### Averages hide the tail

The law constrains means, not percentiles. Systems average fine yet fall over during minute-scale spikes; pair this arithmetic with load testing and tail-latency budgets before treating any solved number as safe capacity.

## FAQs
### What exactly counts as W?

Total time inside the system; queue wait plus processing. Measuring only service time understates L badly.

### Why must I leave one field blank?

Three values overdetermine the law; entering all three invites inconsistent data. Two inputs uniquely determine the third.

### Does this apply to async/thread-pool servers alike?

Yes; the law is measurement-model agnostic. It constrains whatever system boundary you define consistently.

## Related calculators
- [Rate Limit Planner](https://codeasystem.com/calculators/developer/rate-limit-calculator/)
- [API Pagination Calculator](https://codeasystem.com/calculators/developer/api-pagination-calculator/)
- [Uptime SLA Calculator](https://codeasystem.com/calculators/developer/uptime-sla-calculator/)

---
Last updated: 2026-08-23 · Version: 1.0.0 · [HTML version](https://codeasystem.com/calculators/developer/concurrency-throughput-calculator/)