Technology

Monitoring Microservices with the RED Method

November 10, 2026
Monitoring Microservices with the RED Method

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.

Author

Tanay Agarwal

Tanay Agarwal

Software Engineer