microservices-patterns

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

Updated Sep 10, 2025
One-click install
npx skills add https://github.com/cuoreinpace/bdeornelas.github.io --skill microservices-patterns-cuoreinpace
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: microservices-patterns
Source: https://github.com/cuoreinpace/bdeornelas.github.io/tree/main/plugins/backend-development/skills/microservices-patterns
Command: npx skills add https://github.com/cuoreinpace/bdeornelas.github.io --skill microservices-patterns-cuoreinpace

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

This Skill provides a comprehensive guide and practical examples for designing and implementing microservices architectures, focusing on key patterns for 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 for database-per-service and distributed transactions (Saga).
  • Resilience: Applying patterns like Circuit Breaker, Retry, and Bulkhead.
  • Use Case: When building a new distributed system or migrating a monolith, use this Skill to understand and apply best practices for service boundaries, inter-service communication, and fault tolerance.

Quick Start

Use the microservices-patterns skill to learn about designing service boundaries and implementing event-driven communication.

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?▼

To decompose a monolith into microservices, apply business capability or subdomain-based decomposition strategies to define bounded service boundaries. This approach separates functionalities into autonomous, distributed services.

What is the best way to handle distributed transactions in microservices?▼

The best way to handle distributed transactions in microservices is implementing the Saga pattern. It sequences local transactions across services, ensuring data consistency without a distributed two-phase commit.

How does event-driven architecture work for inter-service communication?▼

Event-driven architecture enables asynchronous inter-service communication by having services publish and subscribe to events. This decouples services, improving scalability and resilience compared to synchronous REST or gRPC calls.

When should I use the Circuit Breaker pattern in distributed systems?▼

Use the Circuit Breaker pattern in distributed systems to prevent cascading failures when an inter-service call fails repeatedly. It stops traffic to the failing service, allowing it to recover and building fault tolerance.

Do I need a database-per-service for microservices architecture?▼

A database-per-service is recommended for microservices architecture to ensure loose coupling. It allows each service to manage its own data independently, which is critical when applying Saga pattern transactions or event-driven updates.

Why does synchronous communication impact microservices resilience?▼

Synchronous communication like REST or gRPC impacts microservices resilience because services must wait for responses, creating tight runtime coupling. Adding resilience patterns like Retry or Bulkhead helps isolate these failures.