Response-Time Budgets: Deciding What “Fast Enough” Means
Everybody agrees the website should be fast. Nobody agrees what fast means. Ask three people and you get "instant," "a couple of seconds," and "faster than it is now," none of which a monitoring system can check. Meanwhile the site drifts: a little slower after every release, a little heavier after every new widget. Then one day a customer complains. It turns out the search page has taken four seconds for a month and nobody noticed. No alert was ever told that four seconds was too many.
A response-time budget fixes that. It is a specific, agreed number for how long a page or endpoint may take, measured in a specific way. Your monitoring compares against it every minute of the day. This guide shows you how to set one per page type and API endpoint. The method uses percentiles instead of averages, with a middle "degraded" state between fast and down. The budget is adjusted for time of day and derived from a real baseline. It is reported to the people who care in a way they can trust. You will finish with a method you can apply to any site by next week.
In this guide
- A budget is a promise, not a wish
- Why averages lie and percentiles tell the truth
- Different pages, different budgets
- Slow is a state: degraded versus down
- Time of day and the shape of web traffic
- Worked example: a budget from a baseline
- Reporting budgets honestly
- Loosen the budget or fix the site?
- Where to go next
A budget is a promise, not a wish
"We would like the site to be fast" is a wish. "The search results page returns within 1.5 seconds for at least 95 percent of external checks, measured over each rolling hour" is a budget. The difference is not the precision of the number. It is that the second sentence can be true or false at any moment. That means a monitoring system can watch it and a person can be held to it.
A budget has three parts. A target: the number of seconds. A share: how much of the time the target must be met, because no site meets any target every single time. And a method: measured from where, how often, on which page, over what window. Leave out any of the three and the budget will be argued about in the middle of an outage, which is the worst possible time to define terms.
Two failure modes are worth naming up front. A budget nobody can meet is a lie that trains people to ignore alerts. A budget nobody agreed to is a wish with a threshold attached. The first time it fires, someone will ask who decided that. And the honest answer will be "the monitoring person, alone, on a Tuesday." A budget is a promise made to users on behalf of the whole organization. So the number should be set with the people who own the page, not just the people who watch it.
Why averages lie and percentiles tell the truth
The natural first instinct is to alert on the average response time. Resist it. Averages hide exactly the thing budgets exist to catch: the slow tail. Consider twenty checks of the same page in one hour, sorted from fastest to slowest, in milliseconds:
180 190 195 200 205 210 210 215 220 225 230 240 250 260 280 310 350 1650 2150 2750
The average is about 525 ms. Sounds fine. But three of those twenty checks took two to three seconds. That means roughly one visitor in seven waited long enough to consider leaving. A budget of "average under 600 ms" would call this hour healthy. Now look at the same numbers through percentiles. A percentile is the value that a given share of readings fall at or below. The median (50th percentile) is about 228 ms: the typical experience. The 95th percentile is 2150 ms: what the unluckiest one-in-twenty visitor got. The 99th percentile is the very worst tail. Those three numbers describe the hour honestly; the average described a visitor who does not exist.
The computation is easy. Sort the readings, then take the value at the position that corresponds to the share you want. For the 95th percentile of twenty readings, take the value at position nineteen. If you have met this idea in bandwidth monitoring, it is the same tool applied to a different quantity. The guide on the 95th percentile explained walks through the arithmetic in detail.
One honest caveat: percentiles need enough readings to mean anything. With a check every minute, an hour gives you sixty readings. So the 95th percentile is the third slowest and the 99th percentile is simply the slowest one. That slowest reading is just noise with a fancy name. Use the 95th percentile over an hour for most pages. Reserve the 99th for endpoints you check often enough (or across enough locations) to have hundreds of readings per window.
Keep errors out of the timing math entirely. A request that fails in 50 milliseconds is not a fast response. It is a broken one, and folding it into the percentile makes a failing site look quicker. Count errors separately, report the error rate beside the percentile, and let the budget apply only to requests that actually succeeded.
Different pages, different budgets
One budget for the whole site is almost always wrong, because the pages do different amounts of work and users expect different things from them. Nobody minds a report export taking a few seconds; everybody minds a login taking that long. The table gives starting points that reflect typical expectations and typical work. Treat them as a first draft to be replaced by your own baseline, not as a standard.
| Page or endpoint type | Typical work | Starting budget (95th percentile) | Why |
|---|---|---|---|
| Static or marketing page | Serve cached content | under 1 s | No excuse to be slow; first impression of the site |
| Home page (dynamic) | Template plus a few queries | under 1.5 s | Busiest page; sets the mood |
| Login | Password check, session setup | under 1.5 s | Users are waiting to do something; slowness reads as "broken" |
| Search results | Query against a large index | under 2 s | Genuine work, but users repeat it constantly |
| Checkout or form submission step | Validation, writes, third-party calls | under 3 s | Includes outside dependencies; users will wait, but not long |
| API read (used by an app or mobile client) | One query, small payload | under 500 ms | Apps call several of these per screen; delays multiply |
| API write | Validation plus database writes | under 1 s | Users see a spinner; a second feels responsive |
| Report or export | Heavy query, large response | under 10 s, or measured as a job | Users expect a wait; monitor completion rather than speed |
| File download | Streaming a large object | time to first byte under 1 s; then throughput | Total time depends on file size and the user's connection, not on you |
Two rules hide in that table. First, budget the first byte for anything large, and the total for anything small, because total time on a big download mostly measures the customer's connection. Second, API endpoints deserve tighter budgets than pages, because an application screen typically makes several calls and the user experiences the sum. Which pages and endpoints to put on the list at all is covered in the guide on monitoring what customers actually touch.
Slow is a state: degraded versus down
Most monitoring starts with two states, up and down, and slowness gets shoved into one of them. Shove it into "up" and nobody hears about a site that takes six seconds. Shove it into "down" and the pager fires at three in the morning for a page that works, just slowly. In that case, the on-call person learns to resent the check. The fix is a third state, degraded: the site is answering, but outside its budget.
Give each state its own rule and its own response:
- Healthy. Responses succeed and the percentile is inside the budget. No action.
- Degraded. Responses succeed but the percentile has been outside the budget for a sustained period, typically several consecutive windows rather than one. Open a ticket or a low-priority alert during business hours; page only for pages the business has explicitly declared critical.
- Down. Responses fail, or the page is so slow that requests time out. Page immediately, after confirmation from more than one location.
The boundary between degraded and down is worth a sentence of policy, because "slow enough for long enough" is down as far as the customer is concerned. The guide on defining "down" helps you write that sentence for your own organization. A common approach is a second, much larger threshold. Inside budget is healthy, and above budget is degraded. Above a hard ceiling (say, five times the budget or a fixed timeout) is down. Add a recovery rule too: degraded should clear only after the percentile has been back inside budget for a window or two. That way, a site hovering at the line does not flap between states all afternoon.
Tip: put the budget in the alert text. "Search page degraded: 95th percentile 2.9 s over the last hour, budget 2.0 s, from 3 of 3 locations" tells the reader what was promised, what happened, and how sure you are. "Search page slow" tells them nothing they can argue with or act on.
Time of day and the shape of web traffic
Web traffic has a shape. A business site climbs through the morning, peaks late morning or early afternoon, dips at lunch, and falls away in the evening. A consumer site does the opposite and peaks after dinner. Nearly every site has a weekly rhythm too, and many have monthly or seasonal ones: end-of-month billing runs, enrollment periods, holiday campaigns, launch days. Response time follows the same shape, because the server is busiest exactly when the most people are waiting.
This matters for budgets in two ways. First, a baseline measured mostly at night flatters the site: quiet-hour numbers are the best it will ever look. Build the baseline from a period that includes busy hours. Look at the busy-hour percentile separately from the all-day one. The budget has to hold when people are actually there. Second, comparisons must be like with like. A slow Tuesday afternoon compared with last Tuesday afternoon is a real signal; compared with Sunday night it is noise. If your monitoring can compare against the same hour of the same weekday, use that. If not, at least know which hours are your peaks and read the graphs with them in mind.
Locations add a second dimension. A check from the other side of the world carries a few hundred milliseconds of pure distance that no server tuning can remove. Either give each location its own budget (tight near the customers, looser far away) or set a single budget and hold the distant location to a larger allowance. Whatever you choose, write it into the method so the numbers stay comparable over time. The same goes for known events. A nightly backup or a scheduled batch job that slows the site for twenty minutes should be documented. Ideally, it should be excluded from the budget window, rather than left to generate a mysterious degraded state every night at two.
Worked example: a budget from a baseline
Here is the whole method applied to one page. The search results page has never had a budget. You add an external check every minute from three locations near your customers and let it run for two weeks. You record the total response time of each check. Then you look at the results by hour.
Search results page, two weeks, three nearby locations, one check per minute
median 95th pct 99th pct errors
All hours 0.62 s 1.15 s 2.40 s 0.1%
Busy hours (10-15) 0.81 s 1.38 s 2.90 s 0.2%
Quiet hours (0-6) 0.44 s 0.70 s 0.95 s 0.0%
Worst single hour 1.90 s 4.10 s 6.20 s 1.4% (Tue, after a deploy)
Reading it: the typical experience is comfortable, the busy-hour tail is under a second and a half, and one hour after a deploy was genuinely bad. The quiet-hour numbers are pretty but irrelevant; the budget has to hold at ten in the morning. So you propose:
- Budget: 95th percentile of external checks under 1.5 seconds over each rolling hour, from each location near customers.
- Degraded: the percentile stays above 1.5 seconds for three consecutive hourly windows during business hours, or the median exceeds 1.5 seconds for two windows at any hour. Ticket, not page.
- Down: two or more locations see errors or timeouts for two consecutive checks, or the median exceeds 8 seconds. Page.
- Recovery: degraded clears after two consecutive windows inside budget.
Notice that the budget sits just above the busy-hour baseline. That is deliberate. A budget set at the all-hours number would fire every weekday morning and teach everyone to ignore it. A budget set at double the baseline would miss slow drift for months. Just above the busy-hour tail means the site meets it today, with a little room, and any real regression shows up quickly. Take the proposal to whoever owns the search feature and agree it. Write it down with the date and the reasoning. Only then turn the alert on.
Reporting budgets honestly
A budget is only worth having if the people who agreed to it can see how it is doing. The report is where most of the honesty gets lost. A monthly average tells the reader nothing. The claim "the site averaged 0.7 seconds" is compatible with a wonderful month and with a month that contained three terrible afternoons. Report the budget the way it was defined: as the share of windows that met it, with the tail shown, not hidden.
| Page | Budget | Hourly windows inside budget | Busy-hour 95th percentile | Worst hour | Change since last month |
|---|---|---|---|---|---|
| Home | 1.5 s | 99.6% | 0.9 s | 2.1 s (network incident, 14th) | Steady |
| Search | 1.5 s | 97.2% | 1.4 s | 4.1 s (deploy, 9th) | Busy-hour tail up from 1.2 s |
| Login | 1.5 s | 100% | 0.6 s | 1.1 s | Steady |
| Checkout step 2 | 3.0 s | 94.8% | 3.2 s | 7.8 s (payment provider slow, 22nd) | Outside budget: third-party dependency |
A few habits keep the report trustworthy. State the method every time: from where, how often, which percentile, which window. Name the worst hour and, if you know it, why. A stakeholder who sees "97.2 percent" without context assumes the worst. One who sees "one bad hour after the deploy on the 9th, since fixed" trusts the number. Show the trend, since a page that is inside budget but drifting toward the line is the most useful thing in the whole report. And never quietly change the method or the budget between months; if the budget moved, say so and say why.
Loosen the budget or fix the site?
Sooner or later a budget will be breached for weeks, and someone will suggest raising it. Sometimes that is right. The honest test is why the budget is being missed.
| Why the budget is being missed | Right response |
|---|---|
| Traffic grew and the server did not | Fix the site: capacity, caching, tuning. The promise to users has not changed |
| A new feature made the page heavier on purpose | Decide in daylight: is the feature worth the extra second? If yes, raise the budget and record the decision. If no, trim the feature |
| The check moved, or the method changed | Recalibrate. The site did not change; the ruler did |
| A third-party dependency is slow | Fix what you can (timeouts, fallbacks, loading it after the page); budget the rest honestly as outside your control |
| The budget was never achievable | Loosen it, say so plainly, and set a realistic one from the baseline. A budget that is always red is worse than none |
The rule behind the table: loosening a budget is a decision made with the page owner, in daylight, with the reason written down. It is never a threshold edit made at three in the morning to stop an alert. If you find yourself doing the second thing, the alert was probably a degraded-state alert that should have been a ticket. In that case, the fix is the severity, not the number. And when a budget is tightened, which happens after a successful optimization, apply the same discipline in reverse. Record the new baseline and the date, so the next person to read the graphs knows why the line moved.
Where to go next
A response-time budget turns "the site should be fast" into a promise your monitoring can keep. Set it per page and endpoint, because they do different work. Measure it with a high percentile, because averages hide the tail. Give slowness its own state, so the pager stays quiet and the ticket queue stays honest. Build it from a baseline that includes busy hours. Agree it with the page's owner. Report the share of windows that met it. And change it only in daylight with a reason attached.
The measurements this guide relies on come from external checks. Two companion guides show where those numbers come from. The guide on the layers of a single web check breaks a response time into its stages so you can budget the first byte separately from the body. And multi-location checks explains why the budget should be measured from where your customers are. Both live in the Website & Web-Service Uptime Monitoring topic.
Put this into practice with SysPeep Monitor
A budget breach is a symptom. The cause is usually a server, a database, or a link that ran out of headroom during the busy hours. SysPeep Monitor collects CPU, memory, disk, and interface metrics from the machines behind your site over SNMP, WMI, and SSH. It keeps the history you need for a busy-hour baseline. It alerts on thresholds with the noise controls to make a degraded state a ticket rather than a 3 a.m. page. The free trial installs on any Windows machine.
Download Free TrialLearn About SysPeep