Most service dashboards drift over time. Each team adds the panels they care about, layouts diverge, and within a year no two dashboards in the same org look alike. The result is a problem nobody notices until it matters: an on-call engineer paged for an unfamiliar service has to relearn the dashboard before they can even start the investigation. The RED Method fixes this by standardizing the top of every dashboard. Three charts, in a fixed order, built the same way on every service.
What RED measures:
RED stands for three signals. Every service that handles requests reports all three.
Signal | Question it answers |
|---|---|
Rate | How much traffic is the service receiving? |
Errors | How many requests are failing? |
Duration | How long are requests taking? |
The method was created by Tom Wilkie at Weaveworks in 2015, specifically for microservices. Before RED, the dominant framework was USE Utilization, Saturation, Errors, which works well for hardware but breaks down on services. Asking USE for the "utilization" of an authentication API has no clean answer. Asking RED is straightforward.
Framework | Layer | Signals |
|---|---|---|
USE | Hardware / resources | Utilization, Saturation, Errors |
RED | Services / requests | Rate, Errors, Duration |
Four Golden Signals | Services + headroom | Latency, Traffic, Errors, Saturation |
USE is for disks, NICs, CPUs, anything with a measurable busy/queued state. RED is for services that accept and respond to requests. The Four Golden Signals are essentially RED plus saturation, which adds a leading indicator (a service running close to its CPU quota is about to fail even when RED looks healthy).
The deliverable:
Chart | Unit |
|---|---|
Request Rate | requests/min |
4xx vs 5xx Error Rate | errors/min |
API Latency (p50/p95/p99) | seconds |
Every request-handling service exposes this row, no exemptions for internal-only services, low-traffic services, or services that "only expose health checks." Universality is what makes RED valuable. Each exemption forces on-call engineers to context-switch into a service's bespoke conventions during an incident, which is the most expensive time to learn something new.
The sections below explain how to build each of the three charts correctly.
Measuring Rate
Rate is the simplest of the three signals and the most commonly misimplemented.
Rules-
Count every HTTP request the service handles.
Aggregate across all endpoints. No per-route breakdown at this layer.
Express as requests per minute.
Why per-minute, not per-second
Per-second is the default in most metrics backends, and it's the wrong choice for human-readable dashboards. A service handling 300 req/min reads as 5 req/sec on a per-second chart, a near-flat line where spikes get compressed and drops disappear. The same data on a per-minute chart shows actual shape: traffic peaks, deploy dips, incident deltas. The human eye reads minute-scale curves significantly better than second-scale ones at typical API volumes.
Measuring Errors
The single most common error-monitoring mistake is collapsing all non-2xx responses into one "error rate" number.
Class | Meaning | Fault |
|---|---|---|
4xx | Bad input, unauthorized, not found | The client |
5xx | Crashes, timeouts, unhandled exceptions | The service |
Measuring Duration
Latency is measured as three percentiles, p50, p95, and p99, plotted together. Never as an average.
A service with a 200 ms average and a 10-second p99 looks healthy on average and is actively making 1 in every 100 users miserable. On a service handling a million requests a day, that's ten thousand bad experiences invisible to the average.
Percentile | What it represents |
|---|---|
p50 | Median user — half are faster |
p95 | Most users — only 5% are slower |
p99 | Tail — 1% of users, real people |
Scope: top 5 endpoints by traffic
Percentiles need volume to be meaningful. The default scope is the top 5 most-used endpoints by request rate, with a minimum of 20 requests per week to qualify. Below that threshold, percentiles are statistical noise.
Two sides of the same coin: RED and USE together
RED is not a complete monitoring strategy on its own. RED tells you what the customer is experiencing, failed requests, slow responses, dropped traffic. It does not tell you why.
For why, you need USE on the layer underneath: CPU utilization, memory pressure, disk I/O wait, connection pool saturation, GC pause times, thread pool depth.
The standard framing: RED is about how your users feel. USE is about how your machines feel. They are two views of the same system from opposite directions, and both are needed.
Where the Four Golden Signals fit
The Four Golden Signals add saturation to RED. Saturation is a leading indicator, it tells you when a service is running close to its resource limits before it actually fails. In Kubernetes, this is straightforward: compare a pod's CPU usage to its quota and get a 0-to-1 value.
Most teams don't need to formally adopt the Four Golden Signals as a separate framework. Run RED at the top, USE on the infrastructure below, and add a saturation panel for any service running close to its resource quotas. Same coverage, less philosophical overhead.


