p50 Latency Meaning: What Your Dashboard Number Measures
Key takeaways
- p50 latency is the median response time: half of requests finish faster, half slower, and outliers have no effect on it.
- Averages are inflated by slow outliers, so a healthy-looking mean can hide real user pain that the median exposes.
- Compute percentiles by sorting values and interpolating positions; with 10 samples, p90 lands between the 9th and 10th values.
- A flat p50 with a spiking p90 signals a bimodal failure mode like cache misses or connection pool contention, not a capacity problem.
- Set alert thresholds at roughly 1.5-2x your own two-week baseline, sustained for 5-10 minutes, and route p90 breaches to paging.
The p50 latency meaning is simple: it's the median response time, the point where half your requests are faster and half are slower. Unlike an average, it ignores outliers entirely, which is exactly why a healthy p50 can hide a suffering tail. Pair it with p90 to see what your slowest users live with.
What does p50 latency actually mean?
p50 latency is the median response time: sort every request by duration and take the middle one. Half of your requests finish faster than that number, half finish slower. It is not an average, and nothing gets summed or divided.
p50 is a rank, not a calculation over all values
An average lets one 30-second timeout drag the whole number up. A median ignores magnitude entirely; a request at 200ms and one at 20 seconds count identically as "the slow half." That rank-based framing is why the Google SRE book treats percentiles, not means, as the default way to reason about latency (Monitoring Distributed Systems).
The practical upshot for a small team: p50 tells you what your typical customer experiences, which is exactly what your status page and dashboards should lead with. If your p50 is 120ms, the median request really did return in 120ms. We compared p50 against mean latency and where each one misleads on our own blog (p50 vs mean: why your dashboards mislead you).
How is p50 different from average latency?
Average (mean) latency sums every request time and divides by the count, so a handful of slow outliers drags it upward. p50 is the median: half your requests are faster, half are slower. One request taking 4 seconds barely moves the p50, but it can double the average. That is why a dashboard can show an "acceptable" mean while real users are waiting far longer than it suggests. We cover this in more depth in why p50 percentiles beat misleading latency averages.
A worked example: mean vs median on the same 10 requests
Suppose 10 requests return in these milliseconds: 90, 95, 100, 105, 110, 115, 120, 125, 130, 900.
| Metric | Value | What it tells you |
|---|---|---|
| Mean | 199 ms | Inflated by the 900 ms outlier |
| Median (p50) | 112.5 ms | The typical request |
The mean is nearly double the median because of one slow request. Use the mean when you care about total work done (capacity, cost per request). Use p50 when you care about the typical user's experience, and pair it with p90 to see the tail.
How do you compute p50 and p90 step by step?
Take ten API response times in milliseconds from one probe run, unsorted: 200, 120, 400, 180, 220, 160, 300, 240, 140, 260.
Sorting the dataset
Order them smallest to largest: 120, 140, 160, 180, 200, 220, 240, 260, 300, 400. Sorting first matters because percentiles are positions in an ordered list, not arithmetic on raw values. If you average the unsorted numbers you get a mean, which is a different (and less useful) statistic.
Locating p50
With ten values, the median sits between the 5th and 6th sorted values: 200 and 220. Average them: (200 + 220) / 2 = 210 ms. So p50 is 210 ms, meaning half of your requests finished faster and half slower. For even-sized samples, p50 is the midpoint of the two central values; for odd-sized samples it is simply the middle value.
Locating p90 with interpolation
For p90, use the linear interpolation method described on Wikipedia's percentile page: rank = 1 + (P/100)(n − 1). With P = 90 and n = 10, rank = 1 + 0.9 × 9 = 9.1, so p90 falls 10% of the way between the 9th value (300) and the 10th value (400): 300 + 0.1 × (400 − 300) = 310 ms. The 0.1 fraction is why interpolation matters: with small samples, your p90 usually lands between two real data points rather than on one, and rounding down to 300 would understate the tail. Note the spread here: p50 is 210 ms but p90 is 310 ms, a 100 ms gap created almost entirely by that single 400 ms outlier. That gap is the number to watch on your dashboard, because it tells you what your slowest 10% of users are living with while your median looks fine. The same arithmetic applies whether the data comes from your own probes or from the response-time checks described in website latency monitoring for uptime and response times.
What is the difference between p50 and p90 latency?
p50 is the median: half of all requests finish faster than this number, half finish slower. It describes the typical request, and it is the best single number for "what does my user usually experience?"
p90 is the slowest 10%: 90% of requests beat this number, and 10% do worse. It describes your tail, the users who hit a slow path, a cold cache, or a retry storm.
The two numbers answer different questions. p50 tells you whether your API is healthy for the average request. p90 tells you whether your worst experiences are recoverable or whether a segment of users is quietly suffering while the median looks fine.
A rule of thumb: watch p50 for regressions in the typical path, and alert on p90 when the gap between the two widens. The same logic applies to WebSocket message latency, not just HTTP, which we cover in our deep websocket monitoring guide (https://blog.statuspulse.ai/post/deep-websocket-monitoring-subprotocols-latency).
Why can a good p50 hide a bad p90?
Two datasets can report the same p50 and describe completely different services.
Dataset A: tight distribution
Ten requests: 120, 130, 135, 140, 145, 150, 155, 160, 165, 175 ms. The median (p50) sits at 145-150 ms. The p90, the 9th value, is 165 ms. Every user gets roughly the same experience, and the tail is only ~15 ms worse than the median.
Dataset B: bimodal distribution
Ten requests: 100, 110, 120, 130, 140, 150, 850, 880, 920, 950 ms. The p50 is 140 ms, nearly identical to Dataset A. But the p90 is 900 ms. Four out of ten requests are hitting a cache miss, a cold database connection, or a retry path. The median says everything is fine; a large minority of your users are having a genuinely slow experience.
What each pattern suggests in production
A tight distribution means predictable performance; a bimodal one points at a specific failure mode worth hunting, not a capacity problem. This is why percentile SLAs exist: percentile-based latency targets are how CDNs and cloud providers define performance guarantees, because averages hide exactly this tail (Cloudflare's docs on latency and percentiles). If your monitoring only charts p50, Dataset B looks healthy. Alerting on p90 is what surfaces it, the same way protocol-level probes catch what URL checks miss; see our GraphQL API monitoring reference for pairing latency checks with error and health signals.
When should you alert on p50 versus p90?
Alert on p50 for regressions and capacity drift, and on p90 for anything that breaches a user-facing SLA. If your p50 doubles from 120 ms to 240 ms, nothing is down yet, but something changed: a new deploy, a growing table, a connection pool running hot. That is a capacity signal, not a page-your-on-call signal. p90 is where paying customers actually feel latency, so SLA breach alerts belong there.
Setting thresholds that don't page you at 3 AM
Anchor thresholds to your own baseline, not a blog post's number. Take two weeks of data, note your steady-state p50 and p90, and set alerts at roughly 1.5-2x those values, sustained for 5-10 minutes. The sustained window matters: a single slow request or a GC pause should never page anyone.
The tail is noisy by nature, which is why p90 alerts cause most false alarms. Two defenses: alert on p90 over a rolling window rather than per-minute, and route p50 drift to Slack while p90 breaches go to PagerDuty. If a p90 alert fires with p50 flat, check whether it's one endpoint or all of them before treating it as an outage.
How do you read p50 and p90 together on a latency dashboard?
Read the gap, not the lines. If p50 is 120 ms and p90 is 180 ms, your tail is close to your median and most users see roughly the same thing. If p50 stays at 120 ms but p90 climbs to 900 ms, one user in ten is having a bad experience while the dashboard headline looks fine.
Track the p90/p50 ratio over time. A ratio that drifts from 1.5x toward 4x or 5x is usually the first sign of contention: a connection pool filling up, a slow query, a noisy neighbor. Median users mask it because they hit warm caches.
This is why URL checks miss the problem entirely. Protocol-level probes that report response-time percentiles, like the ones StatusPulse documents for its latency monitoring, let you alert on the widening gap before it becomes a 3 AM outage. A flat p50 with a spiking p90 deserves a page.
What p50 target is reasonable for an API or SaaS endpoint?
There is no universal number, but as illustrative ranges: a lightweight read endpoint often sits under 100ms at p50, a typical CRUD endpoint 100-300ms, and anything calling third-party APIs or doing heavy writes 300-800ms. Above 1s at p50, users notice even if your dashboard says "operational."
Copying someone else's target is the real mistake. Pull your own baseline: take two weeks of p50 and p90 data, find your steady-state p50, and set your alert threshold roughly 1.5-2x that. A p50 of 450ms might be fine for your workload and terrible for someone else's.
Then watch the ratio. If p90 stays under about 2x your p50, your tail is healthy. When that ratio drifts upward, a few users are absorbing the pain while your median looks calm.
FAQ
Is p50 the same as the median?
Yes. p50 is the median response time: sort all requests by duration and take the middle value. Half finish faster, half finish slower. Nothing is summed or divided, so a single extreme outlier has no effect on the number, unlike an average where one slow request can inflate the result.
What does p99 latency mean and do I need it?
p99 is the value that 99% of requests beat, so only the slowest 1% fall above it. It captures your most extreme tail: the worst experiences your worst users hit. For most small teams, p50 plus p90 is enough for alerting and SLA work; reach for p99 when you have strict guarantees to defend or a large request volume where even 1% is a lot of users.
Can p50 be higher than p90?
No. Percentiles are ordered by definition: p90 is the value 90% of requests fall below, and p50 is the value 50% fall below. Since half your requests are already faster than p50, p90 must sit at or above it. If your dashboard shows p50 above p90, one of the two numbers is computed or labeled wrong.
How many samples do I need before percentile latency is trustworthy?
More samples make percentiles steadier, especially at the tail. p50 stabilizes fairly quickly because it is the middle of the distribution, while p90 and p99 need far more data points before they stop swinging between probe runs. A practical approach: compare percentile values across several consecutive runs and treat them as reliable once they stop moving much between windows.