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.
The first call plus every retry.
The first backoff. Exponential doubles it each time.
Caps the backoff so exponential growth stays bounded.
How long one call waits before it counts as failed.
When whoever is waiting gives up. For a synchronous API this is the client timeout.
Each layer applying this same policy. Gateway → service → database is three.
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
| Attempt | Waits | Starts at | Failed by |
|---|---|---|---|
| 1 | — | 0ms | 10s |
| 2 | 1s | 11s | 21s |
| 3 | 2s | 23s | 33s |
| 4 · | 4s | 37s | 47s |
| 5 · | 8s | 55s | 1m 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.
Other tools
- EDI viewer & validator (X12 + EDIFACT)
- X.509 certificate decoder
- JSON ↔ XML converter
- CSV ↔ JSON converter
- OpenAPI linter
- MCP tool-definition linter
- OpenAPI → agent tools
- Agent blast-radius calculator
- Prompt secret scanner
- Agent cost & context calculator
- Agent-readiness scorecard
- iPaaS readiness assessment
- Modernisation roadmap generator
- Migration risk register
- Cutover runbook builder
- Interface catalogue builder
- Migration wave planner
- Function Point estimator
- Platform migration assessor
- Fixed-width flat file parser
- webMethods flow reader
- SAP IDoc viewer
- SWIFT MT & ISO 20022 viewer
- HL7 v2 message viewer
- XSLT tester
- XPath tester
- CI/CD workflow security linter
- Regex tester & ReDoS checker
- Webhook signature verifier
- SLA & error budget calculator
- JSONPath tester
- JSON Schema generator
- Encoding & mojibake fixer
- JSON formatter & validator
- JSON diff
- Epoch & timestamp converter
- Base64 encoder & decoder
- UUID & ULID generator
- JWT decoder
- Cron expression explainer
- Interface math calculator
- Post-quantum migration matrix
- Post-quantum exposure calculator
These exist because the underlying problem is real. If the numbers you just put in look uncomfortable, that is usually worth a conversation.

