Skip to content
← Tools
Integration & APIs

Retry & backoff simulator

Model a retry policy against the caller's deadline, and see how many attempts happen after everyone has given up — plus what nested retries do to the service at the bottom.

5

The first call plus every retry.

1s

The first backoff. Exponential doubles it each time.

30s

Caps the backoff so exponential growth stays bounded.

10s

How long one call waits before it counts as failed.

30s

When whoever is waiting gives up. For a synchronous API this is the client timeout.

3

Each layer applying this same policy. Gateway → service → database is three.

50/s

Traffic entering the top of the chain.

Worst case

1m 5s

Before the caller is told it failed

Expected

1m 5s

Same as worst case without jitter

Amplification

125×

One request becomes 125 at the deepest layer

Attempt timeline

  • Attempt in time
  • Starts after the deadline
  • Deadline · 30s
AttemptWaitsStarts atFailed by
10ms10s
21s11s21s
32s23s33s
4 ·4s37s47s
5 ·8s55s1m 5s

Critical

2 of 5 attempts happen after the caller has given up

The caller's deadline is 30s, but attempt 4 does not even start until 37s. Those attempts cannot help anyone — the response has nowhere to go — while still consuming a connection, a thread and a database handle on a system that is already failing. This is the configuration that turns a slow dependency into an outage.

Critical

One request at the top becomes up to 125 at the bottom

5 attempts at each of 3 layers multiply rather than add. At 50 req/s entering the chain, the deepest service can see 6,250 req/s — 99% of which is retries. Each layer's policy looks reasonable on its own; nobody owns the product. This is why a small dependency blip becomes a full outage.

Critical

No jitter — every client retries at the same instant

Clients that fail together back off by identical amounts and therefore return together. The recovering service is hit by the entire population at 1s, fails again, and the herd re-forms. Full jitter — a random wait between zero and the computed backoff — spreads the same load across the window and costs nothing.

Deterministic: jitter is modelled as a range rather than sampled, so the same inputs always give the same answer. The number worth carrying away is the amplification — retries compose multiplicatively down a chain, and it is the one figure nobody owns, because each layer's policy looks reasonable on its own.