Quick answer
An Apdex score (Application Performance Index) is an open-standard 0–1 measure of user satisfaction with response time: samples at or below threshold T count 1, up to 4T count 0.5, slower ones and errors count 0; the score is (satisfied + tolerating ÷ 2) ÷ total samples.
Formula: Apdex = (satisfied + tolerating ÷ 2) ÷ total samples
What is an Apdex score?
An Apdex score (Application Performance Index) is an open-standard number between 0 and 1 that summarizes how satisfied users are with an application's response time. The Apdex Alliance published the technical specification (V1.1, ©2007), so any tool can implement the same math — which is why APM products such as New Relic and Dynatrace report comparable scores. A score of 1 means every request met the target; 0 means every request frustrated its user.
Apdex exists to replace averages. A mean response time of 300 ms can hide a slow 10% of requests that drives users away, and one 60-second outlier can drag a healthy service's average upward. Apdex instead scores each request individually against a target threshold T — satisfied, tolerating, or frustrated — and averages those scores, so the unit becomes user satisfaction rather than milliseconds. That makes it a standard fixture in real-user and application monitoring.
The catch, and the thread running through this article: the score is only as meaningful as T. Set T wrong and every number downstream is wrong — and for web page experience, Core Web Vitals is the more common choice.
The Apdex formula and three zones
Every request sample falls into one of three zones, defined by the target threshold T:
- Satisfied: response time ≤ T. The user perceives the response as instant. Counts as 1.
- Tolerating: response time > T and ≤ 4T. Noticeably slow but acceptable. Counts as 0.5.
- Frustrated: response time > 4T. Counts as 0. The frustrated boundary F is fixed at 4T by the specification — you configure T, not F.
Apdex = (satisfied + tolerating ÷ 2) ÷ total samples
Two rules from the specification matter more than they look:
- Errors count as frustrated. A failed request — a 404 or a server error — scores 0 no matter how fast it failed. Fast failure is still failure. User-aborted requests are counted too.
- Errors stay in the denominator. Total samples includes every request, failures included. Dropping errors from the calculation inflates the score; the worked example below shows by how much.
Sanity check from the spec itself: traffic that is 80% satisfied, 10% tolerating and 10% frustrated scores 0.80 + 0.10 ÷ 2 = 0.85.
Worked example: same traffic, two thresholds
Sample data: 1,000 requests to one endpoint in an hour, bucketed by response time.
| Response time | Requests |
|---|---|
| ≤ 0.5 s | 600 |
| 0.5–1 s | 150 |
| 1–2 s | 130 |
| 2–4 s | 80 |
| > 4 s | 20 |
| Errors (any duration) | 20 |
| Total | 1,000 |
With T = 0.5 s (F = 2 s): satisfied = 600; tolerating = 150 + 130 = 280; frustrated = 80 + 20 + 20 errors = 120.
Apdex = (600 + 280 ÷ 2) ÷ 1,000 = 740 ÷ 1,000 = 0.74 → Fair.
With T = 1 s (F = 4 s): satisfied = 600 + 150 = 750; tolerating = 130 + 80 = 210; frustrated = 20 + 20 errors = 40.
Apdex = (750 + 210 ÷ 2) ÷ 1,000 = 855 ÷ 1,000 = 0.855 → Good.
Nothing about the service changed — same traffic, same hour. Only the definition of "instant" changed, and the score jumped a full band. That is why the spec requires reporting the threshold alongside the score, in the format score[T]: this hour is 0.74 [T=0.5] or 0.86 [T=1.0], never a bare "0.86".
Now the error trap: if the 20 errors are quietly dropped from the T = 0.5 s calculation, the score becomes (600 + 280 ÷ 2) ÷ 980 = 740 ÷ 980 = 0.755. The service "improved" without a single fix. Errors must stay in the denominator as frustrated samples.
What is a good Apdex score?
The specification's Table 3 defines five rating bands:
| Score | Rating |
|---|---|
| 0.94–1.00 | Excellent |
| 0.85–0.93 | Good |
| 0.70–0.84 | Fair |
| 0.50–0.69 | Poor |
| 0.00–0.49 | Unacceptable |
Most teams treat 0.85 as the working target and 0.94 as the stretch goal. One wrinkle when reading vendor docs: Dynatrace's knowledge base lists Poor as 0.69–0.49, which puts a score of 0.49 in Poor, while the spec puts 0.00–0.49 in Unacceptable. It is a rounding difference at the boundary; when the two disagree, the specification governs.
And a band is only meaningful at a fixed T. As the example showed, 0.74 [T=0.5] and 0.86 [T=1.0] describe identical traffic — comparing scores across services or periods without matching T tells you nothing.
How to choose the Apdex threshold T
T is the response time at which users perceive the interaction as instant — not your current performance, and not an industry average. New Relic's documentation uses T = 0.5 s for an app server as its example, but the value is yours to set per application or transaction type: a search API and a PDF export should not share one T.
Three judgment rules:
- If T equals your current p95, the score will always sit near 0.95. By construction, about 95% of samples are ≤ T, so the metric can never alarm. T is a target, not a description of today — don't derive it from your own percentiles.
- If a healthy week scores below 0.9, T is probably too tight. You picked an aspirational number rather than what users actually perceive as instant. Recalibrate against the task, then re-baseline.
- Once set, keep T fixed. Change T and every historical comparison breaks. If you must change it, restate history under the new T or annotate the break — and always publish the score with its T.
Apdex vs Core Web Vitals
For web pages, the more common lens is Core Web Vitals (CWV). Both compress performance into ratings, but they differ in almost every design choice:
| Apdex | Core Web Vitals | |
|---|---|---|
| What it measures | Request / transaction response time | Page experience: loading (LCP), interactivity (INP), visual stability (CLS) |
| Who sets thresholds | You, per app: custom T, F = 4T | Google, fixed: LCP ≤2.5 s / ≤4 s / >4 s; INP ≤200 ms / ≤500 ms / >500 ms; CLS ≤0.1 / ≤0.25 / >0.25 |
| Output | One 0–1 score plus a band | Three metrics, each rated good / needs improvement / poor |
| Aggregation | Mean of per-sample scores | 75th percentile of real-user data, mobile and desktop separately |
| Errors | Counted as frustrated | Not measured |
| Comparability | Only within the same T | Fixed thresholds make sites cross-comparable |
| Typical use | API and server-transaction SLAs, APM | Web page experience, Search Console reporting |
CWV's fixed thresholds remove the T problem entirely: nobody can flatter a slow site by redefining "instant", and LCP at the 75th percentile means three out of four real visits met the target — a stricter, comparable bar. Apdex still earns its place where you need one number for a server-side SLA. Neither replaces the other: CWV doesn't see errors, and Apdex doesn't see layout shift or visual completeness.
Common mistakes and limits
- Comparing scores across different T values. The two-threshold example above is the whole caution: 0.74 and 0.86 were the same hour.
- Tail flattening. Everything beyond 4T scores 0. At T = 1 s, a 4.1 s response and a 40 s response are indistinguishable in the score. Keep a p95/p99 latency chart alongside Apdex.
- Small samples. New Relic notes the score is unstable below roughly 100 requests per minute; a handful of slow requests swings it wildly. Aggregate over longer windows for low-traffic endpoints.
- Response time isn't the whole experience. Apdex ignores layout shift, visual completeness and whether the user's task actually succeeded.
- Not an SEO signal. Google's page-experience assessment uses Core Web Vitals, not Apdex. Improving Apdex alone changes nothing in Search Console.
How to read real-user performance in TapCub
Say you wanted Apdex for your web pages because you need one banded view of real-user experience. TapCub does not have an Apdex metric and cannot compute one, and converting Core Web Vitals into an Apdex score would be wrong anyway: there is no T to apply. Here is what you get instead, in four steps:
- Open Monitoring › Performance. The numbers come from real page loads in visitors' browsers; the website script reports vitals by default. Five cards cover LCP, CLS, INP, FCP and TTFB, each rated against fixed thresholds: good at most 2.5 s, 0.1, 200 ms, 1.8 s and 800 ms, poor above 4 s, 0.25, 500 ms, 3 s and 1.8 s, needs improvement in between. Those fixed bands take the place of a T you would otherwise have to choose.
- Read P75 and the share rated good. Switch the cards to P75 (they also offer P95, median and average) and break down by page, country, device, browser or operating system; the mobile vs desktop split from the comparison table is the device breakdown. The Slowest pages list is sorted by P75 LCP, and slow loading websites walks through finding the cause. The page also shows a 0–100 score that combines LCP, INP and CLS. It is TapCub's own summary, not an Apdex score, and the two are not comparable.
- Keep the "frustrated" piece separate in Monitoring › Errors. With error collection turned on in the install snippet, the cards show error count, error rate (errors ÷ pageviews), affected visitors and affected sessions, and each error group expands to individual occurrences. Apdex folds failed requests into its score as frustrated; here they stay a separate error rate, so a fast page that throws errors is not hidden behind a good LCP.
- Alert on errors with monitors. In All-platform analytics › Operations › Monitors, the built-in
error_rateanderrorsmeasures can be checked hourly or daily, and a dry run reports how many times a rule would have fired over the past 30 days. Monitors only notify; they take no action for you.
Boundaries, stated plainly: Core Web Vitals measure page experience, not server-transaction response time, so the Apdex formula cannot be applied to them. If you need a genuine Apdex score for a backend SLA, use an APM tool that implements the Apdex specification (vendor docs are in Sources). Neither Performance nor Errors has a previous-period comparison in the header, and TapCub measures: it does not change your code or hosting. For the full routine, see web performance monitoring.
Sources
- Apdex Alliance, Apdex Technical Specification V1.1 (PDF) — zones, F = 4T, error handling, rating bands, score[T] format.
- New Relic Docs, Apdex: Measure user satisfaction — worked example, apdex_f, low-RPM instability.
- Dynatrace Knowledge Base, What is Apdex? — vendor band table and limits.
- web.dev, Web Vitals — good targets and the p75 rule.
- Google Search Console Help, Core Web Vitals report — three-band thresholds for LCP, INP, CLS.
Was this explanation clear?
We use your answers to fix and expand this page.
Couldn’t send. Please try again in a minute.
Thanks for the feedback. We’ll use it to improve this page.You’ve already sent feedback on this page. Thanks.

Data Engineer
Writes about event design, data quality, and collection workflows, with verifiable implementation methods for reliable analytics.