resilience-patterns

Implement circuit breaker and retry patterns for resilient service integrations.

5|1|Updated Jun 17, 2026
One-click install
npx skills add https://github.com/roanbrasil/engineer-grade-agent-skills --skill resilience-patterns-roanbrasil
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: resilience-patterns
Source: https://github.com/roanbrasil/engineer-grade-agent-skills/tree/main/skills/resilience-patterns
Command: npx skills add https://github.com/roanbrasil/engineer-grade-agent-skills --skill resilience-patterns-roanbrasil

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Production systems face unplanned outages, cascading failures, and latency spikes when they lack proper resilience guardrails for downstream dependency failures, network issues, and resource exhaustion. This Skill eliminates those risks by providing battle-tested patterns and production-tuned configurations to keep systems available under failure conditions.

Core Features & Use Cases

  • Failure Mode Classification: Taxonomy for crash, omission, timing, and byzantine failures with targeted detection and recovery strategies for each.
  • Core Resilience Patterns: Production-grade implementations of circuit breaker, retry with exponential backoff and jitter, bulkhead isolation, rate limiting, timeout enforcement, fallback hierarchies, request hedging, health checks, and load shedding.
  • Operational Practices: Chaos engineering workflows for proactive failure testing, SLO/error budget tracking for reliability governance, and pattern composition guidance for layered defense.
  • Use Case: For an e-commerce order processing system, apply these patterns to prevent a slow inventory service from cascading failure to the payment and shipping services, with a fallback that returns a "payment deferred" status when the payment provider is unavailable.

Quick Start

Use the resilience-patterns skill to implement circuit breaker and retry logic for the payment service integration, with production-tuned parameters and a fallback that returns deferred payment status when the service is unavailable.

Frequently Asked Questions about resilience-patterns

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I prevent cascading failures when a downstream service dependency becomes unresponsive?

To prevent cascading failures from unresponsive downstream dependencies, apply circuit breaker patterns with fallback hierarchies and bulkhead isolation. This stops latency spikes and resource exhaustion from propagating across polyglot backend services, maintaining availability during partial outages.

How do I implement retry logic with exponential backoff and jitter for external API calls?

Implement retry logic using exponential backoff with jitter to prevent thundering herds during external API recovery. Combine this with timeout enforcement and request hedging to ensure fault-tolerant communication, avoiding resource exhaustion while waiting for unresponsive downstream dependencies.

What is the best way to isolate resources in a cloud-native architecture to handle latency spikes?

The best way to isolate resources during latency spikes in cloud-native architectures is bulkhead isolation. By partitioning connection pools and threads dedicated to specific downstream dependencies, you prevent resource exhaustion in one service from degrading the entire system's availability.

Can I use chaos engineering workflows to proactively test fault tolerance in event-driven systems?

Yes, you can use chaos engineering workflows to proactively test fault tolerance in event-driven systems. These workflows inject controlled failures like latency spikes and dependency crashes to validate your circuit breaker, timeout enforcement, and fallback mechanisms before production outages occur.

Why do I need SLO and error budget tracking for my microservices?

You need SLO and error budget tracking for microservices to govern reliability and meet 99.9%+ availability targets. Tracking error budgets quantifies how much unreliability is tolerable, guiding when to prioritize resilience improvements like load shedding over deploying new features.

Does the resilience-patterns approach work with polyglot backend services using Java, Python, and Rust?

Yes, the resilience-patterns approach works with polyglot backend services using Java, Python, and Rust. It provides production-grade implementations of fault-tolerant communication patterns suitable for event-driven and cloud-native architectures interacting with external APIs, databases, and message brokers.