distributed-system-patterns

Implement circuit breaker, retry, timeout, bulkhead, saga, and outbox patterns.

Updated Jan 16, 2026
One-click install
npx skills add https://github.com/cornmanwtf/ABANG-COLEK --skill distributed-system-patterns
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: distributed-system-patterns
Source: https://github.com/cornmanwtf/ABANG-COLEK/tree/main/skills/architecture-design/distributed-system-patterns
Command: npx skills add https://github.com/cornmanwtf/ABANG-COLEK --skill distributed-system-patterns

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill provides a structured approach to implementing critical distributed system patterns, enhancing the reliability, fault tolerance, and maintainability of complex software architectures.

Core Features & Use Cases

  • Pattern Implementation: Guides the implementation of circuit breaker, retry, timeout, bulkhead, saga, and outbox patterns.
  • Design Guidance: Offers decision trees for selecting appropriate patterns based on constraints like latency, consistency, and compliance.
  • Use Case: When building a microservices architecture, this Skill can be used to design and implement robust communication strategies between services, ensuring that failures in one service do not cascade and bring down the entire system.

Quick Start

Use the distributed-system-patterns skill to implement a circuit breaker pattern for the user-authentication service.

Frequently Asked Questions about distributed-system-patterns

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

FAQPage Schema
How do I implement a circuit breaker for microservices communication?

Implementing a circuit breaker for microservices involves applying resilience patterns to stop failure cascades and isolate faults. This Skill provides structured guidance and decision trees to design robust communication strategies that maintain system reliability.

What is the best way to handle distributed transactions and data consistency?

Handling distributed transactions and data consistency is best achieved using saga and outbox patterns. This Skill guides the implementation of these patterns to manage complex distributed workflows while addressing non-functional requirements like latency and compliance.

How do I select the right resilience patterns for my system architecture?

Selecting the right resilience patterns requires evaluating system context, constraints, and non-functional requirements. This Skill offers decision trees to help you choose appropriate patterns like retry, timeout, and bulkhead based on your target stack.

When should I use bulkhead and timeout patterns in distributed systems?

You should use bulkhead and timeout patterns in distributed systems when you need to achieve fault isolation and prevent resource exhaustion. They are critical for maintaining availability and ensuring localized failures do not cascade.

Can I use these fault tolerance patterns with any microservices stack?

Applying these fault tolerance patterns requires understanding your target stack and system context for effective validation. While the patterns are architectural, effective selection and implementation depend on your specific environment and non-functional requirements.