microservices-patterns

Guide microservices design with decomposition, communication, data, and resilience patterns.

6|2|Updated Oct 19, 2025
One-click install
npx skills add https://github.com/amurata/cc-tools --skill microservices-patterns-amurata
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: microservices-patterns
Source: https://github.com/amurata/cc-tools/tree/main/plugins/backend-development/skills/microservices-patterns
Command: npx skills add https://github.com/amurata/cc-tools --skill microservices-patterns-amurata

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) and assets (resource) components.

What problem does it solve?

This Skill helps developers design and implement complex microservices architectures, addressing challenges in service decomposition, communication, data management, and resilience.

Core Features & Use Cases

  • Service Decomposition: Strategies like business capability and subdomain-based decomposition.
  • Communication Patterns: Implementing synchronous (REST, gRPC) and asynchronous (event-driven) communication.
  • Data Management: Patterns like "Database Per Service" and the Saga pattern for distributed transactions.
  • Resilience Patterns: Applying Circuit Breakers, Retries, and Bulkheads to build fault-tolerant systems.
  • Use Case: When building a new e-commerce platform, use this Skill to define service boundaries for orders, payments, and inventory, and to establish reliable communication between them.

Quick Start

Use the microservices-patterns skill to learn about implementing the Saga pattern for distributed transactions.

Frequently Asked Questions about microservices-patterns

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

FAQPage Schema
How do I decompose a monolith into microservices?

Microservices decomposition can be achieved using business capability and subdomain-based strategies to define service boundaries. This approach breaks down monolithic applications into smaller, independent services aligned with specific business functions.

What is the Saga pattern for distributed transactions?

The Saga pattern is a sequence of local transactions where each transaction updates data within a single microservice. It ensures data consistency across distributed services by automatically rolling back previous operations if a step fails.

How do I build fault tolerance and resilience in distributed systems?

Resilience in distributed systems is built by applying patterns like Circuit Breakers, Retries, and Bulkheads. These strategies prevent cascading failures and ensure the system remains partially operational during partial outages.

What are the best communication patterns for event-driven microservices?

Event-driven microservices rely on asynchronous communication patterns, alongside synchronous options like REST and gRPC. Choosing the right pattern depends on whether services need immediate responses or can react to domain events independently.

Do I need a database per service for microservices architecture?

A database per service is a common data management pattern in microservices to ensure loose coupling. It allows each service to manage its own data independently, though it introduces challenges requiring distributed transaction solutions like the Saga pattern.

When should I not use a microservices architecture?

Microservices architectures introduce significant complexity in distributed data management and communication. You should avoid this approach if your application domain is too small to justify the operational overhead of service decomposition and fault tolerance strategies.