microservices-patterns

Design microservices with patterns for decomposition, communication, data ownership, resilience, and observability.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Microservices often fail in practice due to poor service boundaries, fragile communication, shared-data coupling, and weak resilience/observability, which leads to cascading outages and slow debugging.

Core Features & Use Cases

  • Service decomposition & topology: Guides splitting by business capabilities, applying the strangler fig extraction pattern, and shaping API gateway/BFF edges for clean client contracts.
  • Correct communication choices: Helps choose sync vs async patterns (REST/gRPC/events) and defines practical rules of thumb for when each fits.
  • Data ownership & failure recovery: Enforces DB-per-service and pairs changes with outbox/event patterns and saga coordination where multi-service workflows require it.
  • Operational resilience & observability: Covers timeouts, retries with backoff + jitter, circuit breakers, bulkheads, idempotency, correlation IDs, and distributed tracing to make production behavior diagnosable.

Quick Start

Use this skill to design how your system should split responsibilities and communicate reliably when you’re extracting services because your app is getting too big or you’re struggling with failures between services.

Frequently Asked Questions about microservices-patterns

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

FAQPage Schema
How do I split a monolith into microservices without creating shared-data coupling?

Split a monolith into microservices by applying service decomposition patterns guided by business capabilities, enforcing DB-per-service, and using the strangler fig extraction pattern to migrate functionality incrementally.

When should I use synchronous REST versus asynchronous event-driven communication in distributed systems?

Choose synchronous REST or gRPC for immediate request-response needs, and use asynchronous event-driven architecture when decoupling services or managing multi-service workflows that require reliable background processing.

What is the best way to handle distributed failures and prevent cascading outages in microservices?

Handle distributed failures and prevent cascading outages by implementing operational resilience patterns including timeouts, retries with backoff and jitter, circuit breakers, and bulkheads to isolate failing components.

How do I maintain data consistency across services when using DB-per-service?

Maintain data consistency across services using DB-per-service by applying the outbox pattern for reliable event publishing and saga coordination to manage distributed transactions across multi-service workflows.

Why do I need correlation IDs and distributed tracing for microservices observability?

Correlation IDs and distributed tracing are required for microservices observability to propagate tracing context across service boundaries, making production behavior diagnosable and debugging faster.

Do I need an API gateway or BFF topology for clean client contracts in microservices?

You need an API gateway or Backend-for-Frontend (BFF) topology to shape clean client contracts, providing a tailored edge layer that isolates clients from internal service decomposition complexities.