Resilience Patterns Cheat Sheet: 12 Patterns + A2 Poster
Twelve resilience patterns on one A2 poster, from retries with jitter to circuit breakers, bulkheads and load shedding, plus a retry-storm simulation.
At about 10:45 PDT on 12 June 2025, a policy change with blank fields reached Google Cloud's Service Control, the system that checks API requests. It hit a null pointer and sent the binaries into a crash loop, globally. That part was a bug. Most regions recovered within two hours. us-central1 took up to about 2 hours 40 minutes, and the reason was a recovery problem. When the tasks restarted together, Google's incident report says, "it created a herd effect on the underlying infrastructure it depends on", because Service Control "did not have the appropriate randomized exponential backoff implemented". Four months later, AWS's post-event summary for the 19–20 October 2025 us-east-1 outage described another subsystem that "had entered a state of congestive collapse and was unable to make forward progress". Engineers had to throttle incoming work to get it moving again.
None of the patterns that would have helped is new. What most estates lack is the one-page view: which pattern solves which problem, and when the same pattern makes things worse. This cheat sheet is for the people who have to make those calls: architects, SRE and platform leads, and the CTOs who sign off on the availability numbers. It comes with a printable A2 poster and a small retry-storm simulation you can rerun and argue with.
TL;DR / Key takeaways
- Retries are load, not free insurance. Three retries at each of three layers means up to 64 attempts on the database for one user action. In our model, a bottom dependency failing 99% of the time already sees 47 times the load.
- Jitter is not optional. When 2,000 clients failed together in our simulation, exponential backoff without jitter took 52 seconds to serve them all. Decorrelated jitter took about 6, full jitter about 15. Without jitter the server sat idle between synchronised retry waves.
- Deadlines beat clever backoff. With an unbounded queue and no deadline check, immediate and fixed-interval retries never recovered: over 99% of server work went to requests whose clients had already given up. Dropping expired requests brought every policy back within 8 seconds.
- Budgets and shedding are the outage cure. A 2022 study of 22 public incidents found the retry policy sustained more than half of them, and load shedding was the most common way out.
- Regulators ask for the outcome. DORA Article 7 requires capacity for peaks and resilience under stress. From 11 December 2027 the Cyber Resilience Act asks products not to harm the availability of other services. Both are evidenced with the patterns below.
Download: Editable draw.io file · Open in diagrams.net · A2 poster (PDF) · Chart data (CSV) · Simulation code (Python)
Why this matters now
Outages now come from recovery, not from the first fault. The research name is metastable failure. Bronson and colleagues described it at HotOS 2021 as a system that enters a bad state "that persists even when the trigger is removed". Huang et al. then studied 22 public incidents from 11 organisations at OSDI 2022. They found that "by far, the most common sustaining effect is due to the retry policy, affecting more than 50% of the studied incidents". Load shedding was the most popular mitigation, used in over half. The trigger is usually boring: a deployment, a configuration push, a short network blip. The feedback loop is what keeps you down for hours.
Defaults now do a lot, and they are not tuned for you. Microsoft's AddStandardResilienceHandler for .NET chains five strategies with sensible defaults: a 30-second total timeout, three retries with exponential backoff and jitter, a circuit breaker at a 10% failure ratio, and a 10-second attempt timeout. Envoy defaults to 1,024 pending requests and three concurrent retries per cluster. The OpenAI and Anthropic Python SDKs each retry twice by default. The result: a typical call path now has three or four retry layers that nobody designed together.
Traffic is burstier. Batch jobs, event fan-outs and AI agents that loop on tool calls produce synchronised load, exactly the case where jitter matters most.
The 12 patterns, family by family
The poster groups the patterns by the job they do. A bounds how long anyone waits. B contains a failure to the component that has it. C protects capacity when demand exceeds it. D lets the system fail softly and retry safely.
① Timeouts and deadlines
Every network call needs a timeout, and the library default is rarely the right one. The AWS Builders' Library recommends deriving it from the callee's measured latency. Its example picks the downstream p99.9, accepting that 0.1% of calls will time out spuriously. An inner timeout must be shorter than the outer one, otherwise the caller gives up while the callee is still working. And pass a deadline, not just a timeout. Google's SRE book recommends deadline propagation: the frontend sets the deadline, and each hop passes down the time that is left, so a backend never starts work its caller has already abandoned. gRPC does this natively. Over HTTP you need a header and a little middleware.
The part nobody demos is the server side. A server that does not check deadlines keeps serving requests whose clients have already timed out. In our simulation, that one omission decided whether the system recovered at all.
② Retries with backoff and jitter
Retry only what is likely to succeed next time: connection resets, 503s, 429s with a Retry-After, and timeouts on idempotent calls. Do not retry validation errors or non-idempotent writes without a key (pattern ⑪). Use capped exponential backoff, and always add jitter. Marc Brooker's 2015 AWS Architecture Blog post compared the variants. Unjittered backoff did worst, and full and decorrelated jitter cut the work substantially. The Builders' Library sums up the trade-off: retries are "selfish", because a retrying client spends more of the server's time to raise its own chance of success.
Our simulation below shows the same shape with a different server model. Without jitter, retries arrive in waves the server can only partly absorb, and it idles in between.
③ Retry budgets
A per-request limit such as "at most three attempts" is not enough: in a real outage every request uses its full allowance. Google's SRE book adds a per-client retry budget: a request is only retried "as long as this ratio is below 10%", which "reduces the growth to just 1.1x in the general case". The book also recommends retrying only "at the layer immediately above the layer that is rejecting" the request, because stacked retries multiply. Its example is 64 attempts on the database (4 × 4 × 4) for one user action.
The AWS SDKs have limited retries with a local token bucket since 2016. gRPC's retryThrottling decrements a token count on failure and pauses retries when it falls below half. Envoy's retry_budget, once enabled, defaults to 20% of active requests. If you set one thing after reading this, set a budget.
④ Circuit breaker
A circuit breaker watches calls to a dependency. When failures cross a threshold, it opens and fails fast for a while, instead of letting every caller wait for a timeout. After a pause it goes half-open and lets a trial call through. If that call succeeds, the breaker closes again. Martin Fowler's 2014 write-up credits Michael Nygard's Release It! with popularising the pattern. Polly 8, Resilience4j 2 and Envoy's outlier detection all implement it.
Three things go wrong in practice: samples so small that one slow request trips the breaker, one breaker covering many hosts, and nobody deciding what happens when it opens. Microsoft's standard handler places the breaker inside the retry, with a minimum throughput of 100 calls in a 30-second window, so the breaker stops the retries from hammering a dependency that is already down.
⑤ Bulkhead
A bulkhead gives each dependency, tenant or workload class its own bounded share of threads, connections or memory. When one dependency becomes slow, only its compartment fills up. Without bulkheads, one slow call path drains the shared pool and takes down unrelated features.
Resilience4j has a dedicated bulkhead module. Polly 8 has no separate bulkhead and uses a concurrency limiter (AddConcurrencyLimiter) from its rate-limiting package instead. At fleet scale the same idea becomes cell-based architecture, which we cover in cell-based architecture and blast radius. The usual mistake is too many tiny pools. Normal peaks then queue, so watch rejections per pool from day one.
⑥ Health checks
Health checks decide where traffic goes and which processes get restarted. Mix the two jobs up and the check becomes the outage. The Kubernetes documentation says it plainly: liveness probes "must be configured carefully to ensure that they truly indicate unrecoverable application failure", because a wrong one leads to "restarting of container under high load" and cascading failures. Use readiness to take an instance out of rotation, and liveness only to detect a process that is stuck. Neither should call your database. If it does, one shared dependency outage marks the whole fleet unhealthy at once.
The AWS outage in October 2025 showed the same risk at load-balancer scale. Health checks flapped between failing and healthy and pulled capacity out of service. AWS's stated fix is a velocity control that limits how much capacity a single load balancer can remove. Put the same guard in your own failover automation.
⑦ Rate limiting
Rate limiting protects a shared service from any single client. It works per caller: a quota per API key, tenant or IP, enforced at the edge (API Management, an API gateway or Envoy), with 429 Too Many Requests and a Retry-After header so well-behaved clients know when to come back. Microsoft's standard handler also puts a client-side concurrency limiter outermost, with 1,000 permits by default.
Rate limiting is not overload protection. Quotas are static; real capacity changes with every deployment, cache state and noisy neighbour. A server can be overloaded while every client is within quota.
⑧ Load shedding
Load shedding is the server saying "not now" in time: past a concurrency or queue-age limit, it rejects new work early and cheaply, so accepted work still finishes. David Yanacek's Builders' Library article frames the goal as protecting goodput: throughput "handled without errors and with low enough latency" for the client to use the response. It also gives the practical rules. Make rejection cheap and early. Shed lower-priority traffic first. Protect load-balancer health checks, which it calls the most important request a server receives, because failing them shrinks the fleet in the middle of a brownout. Google's SRE book does the same with request criticality, from CRITICAL_PLUS to SHEDDABLE.
Shedding is also how teams climb out of metastable failures, and it works best when built in and tested, not switched on by hand at 03:00.
⑨ Queue-based load levelling
A queue between producers and workers turns bursts of asynchronous work into a steady stream. Three rules keep it honest. Bound the queue. Drop or dead-letter items whose deadline has passed. Scale workers on queue age, not only on length.
The anti-pattern is a synchronous caller waiting behind an unbounded queue. Latency stays hidden until the queue is minutes long, then everything times out at once and the retries start. The SRE book advises small queues relative to the thread pool, and suggests LIFO or CoDel-style dropping under overload. Our simulation shows why an unbounded queue without deadline checks is the worst setup we tested.
⑩ Fallback and graceful degradation
A fallback returns something useful when the real answer is unavailable: recommendations without personalisation, a price marked "as of 10:02", a checkout that queues the confirmation email. Polly 8 has a fallback strategy. Most good fallbacks are product decisions, though, not library settings.
Fallbacks fail in two ways: they call another fragile service, or they never run until the day they are needed, and then do not work. Test them by forcing the primary to fail. Static stability, where the system keeps running on its last known good state when the control plane is down, is the infrastructure version of this pattern. Our hyperscaler outage anatomy covers it in depth.
⑪ Idempotency keys
Retries are only safe if repeating a request cannot repeat its effect. Writes need an idempotency key. The client generates a unique key per logical operation, and the server stores the outcome and returns it for any retry with the same key. Stripe's API is the reference design. Keys can be up to 255 characters, should be random (V4 UUIDs are suggested), and can be pruned after they are at least 24 hours old. The server compares parameters and rejects a reused key with different ones. The IETF is standardising an Idempotency-Key HTTP header. As of draft 08, updated on 22 October 2026, it is still an Internet-Draft, not an RFC.
Two cautions. Do not build keys from personal data; Stripe explicitly warns against it. And make sure keys outlive the client's whole retry window, including queued and offline retries. This matters even more for APIs that AI agents call, which we cover in agent-ready API design.
⑫ Hedged requests
Hedging attacks tail latency rather than failures. If a request is still outstanding after a short delay, send a second copy to another replica, use whichever answer arrives first, and cancel the other. Dean and Barroso's "The Tail at Scale" (CACM, 2013) reports a Google benchmark reading 1,000 keys from BigTable across 100 servers. A hedge sent after a 10 ms delay reduced the 99.9th-percentile latency "from 1,800ms to 74ms while sending just 2% more requests". They recommend waiting for roughly the 95th-percentile latency before hedging, which caps the extra load at about 5%.
Hedging belongs on idempotent reads. It is harmful when slowness comes from overload, because hedges then add load exactly when the system can least afford it. gRPC caps hedging at five attempts and applies the same retry throttling. Microsoft's AddStandardHedgingHandler keeps a circuit breaker per endpoint, so it does not hedge against an endpoint that is already unhealthy.
What the numbers say: a retry storm, simulated
We wanted to know what retry policy and server design do to recovery after a synchronised failure, so we wrote a small discrete-time simulation in plain Python and published it with this article. The method:
- Trigger. 2,000 clients lose their in-flight request at the same instant, as after a dependency restart or a load balancer dropping connections. Each needs one successful response.
- Server. One FIFO server handling 500 requests per second, simulated in 10 ms ticks. The burst therefore equals 4 seconds of capacity.
- Client. A 1-second timeout per attempt, then a sleep set by the retry policy (base 0.5 s, cap 20 s), then another attempt, until success or the 120-second horizon.
- Server variants. Bounded: the queue holds at most 250 requests (0.5 s of work) and rejects the rest at once, free of charge. Unbounded: everything is queued and deadlines are ignored. Unbounded with deadline drop: everything is queued, but requests whose client has already given up are discarded at dequeue.
- Policies. No backoff, fixed 0.5 s, exponential without jitter, and the three jitter variants Brooker described: equal, full and decorrelated.
- Runs. 25 seeds per configuration, medians reported; chart 1 shows seed 0. Chart 4 is a closed-form calculation, checked by Monte Carlo.
The staircase is the story. With exponential backoff and no jitter, every client that was rejected together retries together: after 0.5, 1, 2, 4, 8 and 16 seconds, then at the 20-second cap. The bounded queue accepts 250 requests per wave and rejects the rest, then the server waits for the next wave. The last client gets in after 52 seconds, even though the server was busy for barely 4 of them. Decorrelated jitter served everyone in about 6 seconds and full jitter in about 15. The jittered curves are smooth because the arrivals no longer line up.
Work tells the other half. Retrying without backoff finished fastest in this idealised model, but took 155 attempts per client, with arrivals peaking at 351 times capacity per 100 ms. That only works because rejection is modelled as free; in real systems it is not. Exponential backoff without jitter used 4.5 attempts per client. Equal, full and decorrelated jitter used 3.2, 3.4 and 2.4. One honest caveat: the fixed 0.5-second interval looks excellent only because 0.5 s × 500 requests per second happens to equal the queue limit. Change either number and it falls apart.
This is the chart we would show an architecture board. With an unbounded queue and no deadline check, the server spends its capacity on requests whose clients have already timed out. Immediate and fixed-interval retries never recovered within 120 seconds, with 99% of server work wasted. That is a metastable failure in miniature: the trigger is long gone, and the retry loop keeps the system down. Policies with exponential backoff, jittered or not, did recover, but only after 33–60 seconds, with around 80% of work wasted. Add one line of server code that drops expired requests at dequeue, and every policy recovered within 8 seconds. In this model, deadline propagation (①) and bounded queues (⑨) mattered more than the choice of jitter.
The last chart generalises the SRE book's 64× example. With three retries at each of three layers, the bottom dependency sees 2× the load when half its calls fail, about 10× at 90%, 47× at 99% and 64× at 100%. The curve is flat when healthy and vertical in an outage, which is why load tests miss it. A 10% retry budget at each layer caps the same stack at 1.33×.
Limitations. This is a toy model on purpose: one server, one queue, free rejections, no background traffic and a perfectly synchronised trigger. Real servers degrade under overload, so our no-backoff numbers are optimistic. Use the results for direction and ranking, not as capacity figures, and change the parameters in retry_storm_sim.py to match your own system.
In a recent engagement…
A European platform team asked us to review why a short, planned database failover regularly turned into a partial outage that lasted many times longer. Nothing in their stack was unusual. The API gateway, the service mesh, the HTTP client and the ORM all retried, each configured sensibly in isolation by a different team.
Drawing the call path on one page was most of the diagnosis. Four retry layers multiplied load on the database proxy just as the failover finished, and the proxy's unbounded connection queue meant the database spent its first minutes back serving requests that had already timed out upstream. The fixes were unglamorous. We removed retries from the gateway and the ORM, kept one retry layer with a budget in the service mesh, added deadline headers and a dequeue check in the two busiest services, and bounded the proxy queue. The next planned failover produced a short blip and no incident. The hardest part was getting four teams to agree which layer owns retries.
Decision table: symptom to pattern
This is the screenshot-able part. Start from the symptom you actually see.
| Symptom you see | First pattern(s) | Where to implement | What to measure |
|---|---|---|---|
| Requests hang for minutes during an incident | ① Timeouts and deadlines | Every client, plus deadline headers | Timeouts per call, p99.9 per dependency |
| Short blips cause user-visible errors | ② Retries with jitter, ⑪ idempotency keys | Exactly one layer per call path | Retry rate, success-after-retry rate |
| Load triples during an outage and recovery stalls | ③ Retry budget, ⑧ load shedding | Client libraries, mesh, servers | Retries / requests, goodput vs. throughput |
| One slow dependency takes down unrelated features | ⑤ Bulkhead, ④ circuit breaker | Per dependency or tenant | Pool saturation, breaker state changes |
| A single noisy client degrades everyone | ⑦ Rate limiting | Edge gateway | 429s per client, top-N callers |
| Restarts cascade across the fleet under load | ⑥ Health checks | Readiness vs. liveness probes | Restarts per hour, probe latency |
| Bursty producers overwhelm workers | ⑨ Queue-based load levelling | Async boundaries | Queue age, expired items dropped |
| The system stays down after the trigger is fixed | ⑧ Load shedding, ① deadline drop, ③ budget | Servers first | Wasted work (expired requests served) |
| A dependency outage blanks the whole page | ⑩ Fallback / degradation | Product + service layer | Fallback activations, staleness |
| Duplicate orders or payments after retries | ⑪ Idempotency keys | Write APIs | Duplicate-key replays |
| p99.9 latency is far above p50 on reads | ⑫ Hedged requests | Read clients | Hedge rate (keep ≤ ~5%), tail latency |
Two rules sit above the table. One retry layer per call path, and every queue has a bound and a deadline check.
Governance for European enterprises
In the EU, these engineering choices increasingly sit under regulatory obligations. Three regimes apply.
DORA (Regulation (EU) 2022/2554), which has applied to financial entities since 17 January 2025, is the most direct. Article 7 requires ICT systems that are "equipped with sufficient capacity" to deal with "peak orders, message or transaction volumes", and that are "technologically resilient" under "stressed market conditions or other adverse situations". Article 9(2) asks for tools that ensure "the resilience, continuity and availability of ICT systems". Article 11 requires response and recovery arrangements that contain incidents and limit damage. A retry storm that turns a short failover into a long outage is exactly the gap a supervisor will probe; documented timeouts, budgets and shedding tests are good evidence. Our DORA implementation guide for Azure maps the rest.
The Cyber Resilience Act (Regulation (EU) 2024/2847) applies its essential requirements from 11 December 2027. Annex I, Part I, point (2)(h) asks products to "protect the availability of essential and basic functions, also after an incident". Point (2)(i) asks them to "minimise the negative impact by the products themselves or connected devices on the availability of services provided by other devices or networks". A client SDK or device fleet that retries without backoff or a budget is a textbook way to harm someone else's availability, so backoff, jitter and budgets belong in your design documentation.
NIS2 (Directive (EU) 2022/2555), Article 21(2)(c), requires essential and important entities to cover business continuity and crisis management. The patterns here are the technical measures that make continuity plans believable.
A pragmatic adoption path
- Week 1: draw the call path. For your top three user journeys, list every layer that sets a timeout or retries: gateway, mesh, SDK, HTTP client, ORM, driver. Most teams find three or more retry layers.
- Weeks 2–3: timeouts and one retry layer. Set timeouts from measured p99.9, inner shorter than outer. Keep one retry layer per call path, with jitter.
- Month 2: budgets and deadlines. Add a retry budget (gRPC throttling, an Envoy retry budget or an SDK token bucket). Propagate deadlines and drop expired work at dequeue in your busiest services. In our simulation, that was the biggest lever.
- Month 3: shed and contain. Add prioritised load shedding to critical services, bound every queue, and put bulkheads and breakers around the dependencies that hurt you most. Add idempotency keys to every write API that clients retry.
- Quarter 2: prove it. Run a game day that forces a synchronised failure, such as a dependency restart, and measure goodput, wasted work and recovery time. Keep the results as DORA or CRA evidence. For long-running workflows, pair this with durable execution, so retries survive process restarts.
The verdict
Outages that last hours are rarely caused by a bigger fault. They are caused by recovery that nobody designed. The twelve patterns are well known and individually easy. The hard part is that they interact. A retry without a budget is an amplifier. A queue without a deadline check is a place where work goes to die. A liveness probe that checks dependencies is a fleet-wide restart button.
Our view is blunt. If you change only three things this quarter, make them these: one retry layer with jitter and a budget, deadlines that servers actually check, and load shedding that is cheaper than the work it protects. Breakers, bulkheads, fallbacks and hedging will not save a system whose retries and queues are fighting it.
If you want a second pair of eyes on a critical call path, our software architecture team runs this exact review: we draw the call path, simulate your retry settings against your real capacity, and leave you with the decision table filled in for your system.
FAQ
What are the most important resilience patterns for microservices?
Start with timeouts on every network call, retries with capped exponential backoff and jitter, and a retry budget of roughly 10% of requests. Those three stop most self-inflicted outages. Then add circuit breakers and bulkheads to contain failing dependencies, load shedding and bounded queues to protect capacity, and idempotency keys before you retry any write. Fallbacks and hedging come last.
Why do retries need jitter?
Without jitter, clients that failed together retry together, so every retry wave hits the server as one spike. In our simulation of 2,000 clients failing at once against a server with a short bounded queue, exponential backoff without jitter took 52 seconds to serve everyone, because only 250 requests got in per wave. Decorrelated jitter took about 6 seconds and full jitter about 15.
What is a retry budget?
A retry budget caps retries as a share of traffic rather than per request. Google's SRE book retries a request only while retries stay below 10% of requests, on top of a three-attempt limit per request. Envoy's retry budget, once enabled, defaults to 20% of active requests, and gRPC throttles retries with a token bucket. Budgets stop retries multiplying load in a real outage.
What is the difference between a circuit breaker and a retry?
A retry repeats one failed call in the hope that the fault was transient. A circuit breaker watches many calls and, once failures cross a threshold, stops calling the dependency for a while and fails fast. The retry handles a blip; the breaker handles an outage and stops retries hammering a dependency that is already down. Microsoft's standard .NET handler places the breaker inside the retry for this reason.
What is a metastable failure?
A metastable failure is an outage that persists after its trigger has gone, because a feedback loop keeps the system overloaded. Retries are the usual loop: requests time out, clients retry, and the extra load causes more timeouts. An OSDI 2022 study of 22 public incidents from 11 organisations found the retry policy sustained more than half of them. Load shedding was the most common way out.
Do EU regulations require resilience patterns?
Not by name, but they require the outcome. DORA Article 7 requires ICT systems with enough capacity for peak volumes and resilience under stressed conditions, and Article 11 requires response and recovery arrangements. From 11 December 2027, the Cyber Resilience Act requires products to protect the availability of essential functions and to minimise their impact on the availability of other services. Timeouts, retry budgets and load shedding are how you evidence that.
Sources
All sources checked on 15 November 2026. Simulation results are our own analysis and are labelled as such. The code is published with the article.
Tier A: primary, standards and regulatory
- Google Cloud, Service Health incident report, 12 June 2025: https://status.cloud.google.com/incidents/ow5i3PPK96RduMcb1SsW
- AWS, "Summary of the Amazon DynamoDB Service Disruption in the Northern Virginia (US-EAST-1) Region" (19–20 Oct 2025): https://aws.amazon.com/message/101925/
- Regulation (EU) 2022/2554 (DORA), Articles 7, 9 and 11: https://eur-lex.europa.eu/eli/reg/2022/2554/oj/eng
- Regulation (EU) 2024/2847 (Cyber Resilience Act), Annex I Part I: https://eur-lex.europa.eu/eli/reg/2024/2847/oj/eng
- Directive (EU) 2022/2555 (NIS2), Article 21: https://eur-lex.europa.eu/eli/dir/2022/2555/oj/eng
- IETF, draft-ietf-httpapi-idempotency-key-header-08: https://datatracker.ietf.org/doc/draft-ietf-httpapi-idempotency-key-header/
- Kubernetes documentation, liveness, readiness and startup probes: https://kubernetes.io/docs/concepts/configuration/liveness-readiness-startup-probes/
- gRPC documentation, retry (including retry throttling): https://grpc.io/docs/guides/retry/
- gRPC documentation, request hedging: https://grpc.io/docs/guides/request-hedging/
- Envoy API reference, circuit breakers and retry budgets: https://www.envoyproxy.io/docs/envoy/latest/api-v3/config/cluster/v3/circuit_breaker.proto
Tier B: research and engineering literature
- Google SRE book, "Handling Overload": https://sre.google/sre-book/handling-overload/
- Google SRE book, "Addressing Cascading Failures": https://sre.google/sre-book/addressing-cascading-failures/
- Huang et al., "Metastable Failures in the Wild", OSDI 2022: https://www.usenix.org/conference/osdi22/presentation/huang-lexiang
- Bronson, Aghayev, Charapko, Zhu, "Metastable Failures in Distributed Systems", HotOS 2021: https://sigops.org/s/conferences/hotos/2021/papers/hotos21-s11-bronson.pdf
- Dean and Barroso, "The Tail at Scale", Communications of the ACM, 2013: https://research.google/pubs/the-tail-at-scale/
- Marc Brooker, "Exponential Backoff and Jitter", AWS Architecture Blog (2015, updated 2023): https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/
- Marc Brooker, "Timeouts, retries, and backoff with jitter", Amazon Builders' Library: https://builder.aws.com/content/3EumjoZascWd1oZiEgL8ORlv3qE/timeouts-retries-and-backoff-with-jitter
- David Yanacek, "Using load shedding to avoid overload", Amazon Builders' Library: https://builder.aws.com/content/3Eun1EEyX6p2e3VYNyRLSJzLuMV/using-load-shedding-to-avoid-overload
- Martin Fowler, "CircuitBreaker" (2014): https://martinfowler.com/bliki/CircuitBreaker.html
- CC Conceptualise, retry-storm simulation (
retry_storm_sim.py) and chart data: https://www.conceptualise.de/blog/resilience-patterns-cheat-sheet/retry_storm_sim.py
Tier C: vendor documentation, directional
- Microsoft Learn, "Build resilient HTTP apps" (standard resilience and hedging handler defaults): https://learn.microsoft.com/en-us/dotnet/core/resilience/http-resilience
- Polly documentation, resilience strategies (Polly 8.9.1, released 7 Nov 2026): https://www.pollydocs.org/strategies/
- Resilience4j documentation (2.4.0; requires Java 17): https://resilience4j.readme.io/docs/getting-started
- Netflix Hystrix README (maintenance mode): https://github.com/Netflix/Hystrix
- Azure Architecture Center, cloud design patterns (Retry, Circuit Breaker, Bulkhead, Queue-Based Load Leveling, Throttling, Health Endpoint Monitoring): https://learn.microsoft.com/en-us/azure/architecture/patterns/
- Stripe API reference, idempotent requests: https://docs.stripe.com/api/idempotent_requests
- Anthropic and OpenAI Python SDKs, default retry settings (
_constants.py): https://github.com/anthropics/anthropic-sdk-python and https://github.com/openai/openai-python
Topics