microservices-patterns

Design distributed microservices with decomposition, communication, data, and resilience patterns.

Updated Apr 23, 2026
One-click install
npx skills add https://github.com/agigante80/forge-kit --skill microservices-patterns-agigante80
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: microservices-patterns
Source: https://github.com/agigante80/forge-kit/tree/main/plugins/forge-kit-backend/skills/microservices-patterns
Command: npx skills add https://github.com/agigante80/forge-kit --skill microservices-patterns-agigante80

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Solves the complexity of designing distributed systems by providing a structured blueprint for creating robust microservices architectures.

Core Features & Use Cases

  • Service Decomposition: guidance on splitting a monolith into independently deployable services aligned to business capabilities.
  • Communication Patterns: choices between synchronous REST/gRPC and asynchronous event-driven messaging with practical guidance.
  • Data Management & Resilience: patterns like database-per-service, sagas, compensation, circuit breakers, retries, and bulkheads.
  • Real-World Scenarios: examples of decompose-then-aggregate flows across Order, Inventory, and Payment services with events.

Quick Start

Outline your current monolith and map it to a three-service architecture with event-driven coordination.

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 independently deployable microservices?

Service decomposition splits a monolith into independently deployable services aligned to business capabilities. You map existing monolithic domains to bounded contexts, establishing clear service boundaries for multi-service environments.

What is the best way to manage distributed data across microservices?

Managing distributed data relies on the database-per-service pattern, sagas, and compensation. This approach maintains data consistency across independently deployable services without relying on shared databases.

How do I choose between synchronous REST and asynchronous event-driven communication for microservices?

Microservices communication patterns offer synchronous REST/gRPC for direct requests and asynchronous event-driven messaging for decoupled coordination. Your choice depends on whether services need immediate responses or can react to events asynchronously.

How do circuit breakers and bulkheads improve resilience in distributed systems?

Circuit breakers, bulkheads, and retries are resilience patterns that prevent cascading failures in distributed systems. They isolate faults and manage resource allocation to maintain partial functionality during service disruptions.

Can I use sagas for transaction coordination across Order, Inventory, and Payment services?

Sagas coordinate distributed transactions across services like Order, Inventory, and Payment using event-driven flows. They ensure data consistency through compensation mechanisms if a step in the multi-service process fails.

When should I not use event-driven microservices architecture?

Event-driven microservices architecture introduces complexity in tracking asynchronous flows and managing distributed state. Avoid this approach if your application requires strictly synchronous, immediate data consistency across all operations.