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.