Microservices Patterns

From the author

Design microservices architectures with service boundaries, event-driven communication, and resilience patterns. Use when building distributed systems, decomposing monoliths, or implementing microservices.

— the description by Seth Hobson

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a structured reference for designing distributed systems using microservices. It covers foundational concepts such as service boundaries, inter-service communication strategies, data management techniques like the Saga pattern, and resilience mechanisms including circuit breakers and bulkheads. The content is designed to assist developers in decomposing monolithic applications and implementing robust service-oriented architectures.

What it does

Explains service decomposition strategies like business capability and domain-driven design.
Details synchronous and asynchronous communication patterns.
Outlines data management approaches including database-per-service and the Saga pattern.
Provides resilience patterns such as circuit breakers, retries, and bulkheads.
Offers code examples for implementing API gateways and event-driven service interactions.

When to use it

When decomposing a monolithic application into smaller services.
When designing service boundaries and defining contracts.
When implementing inter-service communication and event-driven architectures.
When managing distributed data and transactions across services.
When building resilience into distributed systems.

Advantages

Provides clear architectural patterns for service isolation.
Offers guidance on handling distributed data consistency.
Includes practical examples for implementing service communication.
Focuses on fault tolerance through established resilience patterns.

Usage examples

“How should I decompose my monolith into microservices?”: The skill provides strategies like business capability mapping and the Strangler Fig pattern to help you extract services from a monolith.
“How can I handle transactions across multiple microservices?”: The skill explains the Saga pattern, which uses compensating actions to maintain eventual consistency in distributed transactions.
“What is the best way to prevent cascading failures in my microservices?”: The skill suggests implementing resilience patterns such as circuit breakers, retries with backoff, and bulkheads to isolate and manage failures.
“Show me how to implement an API gateway.”: The skill provides a code example demonstrating an API gateway that aggregates data from multiple services and uses a circuit breaker for fault tolerance.

Install

Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/wshobson/microservices-patterns/download

Unzip it into the cross-client skills folder of your project:

mkdir -p .agents/skills && unzip microservices-patterns.zip -d .agents/skills

Documentation by Seth Hobson

Master microservices architecture patterns including service boundaries, inter-service communication, data management, and resilience patterns for building distributed systems.

When to Use This Skill

Decomposing monoliths into microservices
Designing service boundaries and contracts
Implementing inter-service communication
Managing distributed data and transactions
Building resilient distributed systems
Implementing service discovery and load balancing
Designing event-driven architectures

Core Concepts

1. Service Decomposition Strategies

By Business Capability

Organize services around business functions
Each service owns its domain
Example: OrderService, PaymentService, InventoryService

By Subdomain (DDD)

Core domain, supporting subdomains
Bounded contexts map to services
Clear ownership and responsibility

Strangler Fig Pattern

Gradually extract from monolith
New functionality as microservices
Proxy routes to old/new systems

2. Communication Patterns

Synchronous (Request/Response)

REST APIs
gRPC
GraphQL

Asynchronous (Events/Messages)

Event streaming (Kafka)
Message queues (RabbitMQ, SQS)
Pub/Sub patterns

3. Data Management

Database Per Service

Each service owns its data
No shared databases
Loose coupling

Saga Pattern

Distributed transactions
Compensating actions
Eventual consistency

4. Resilience Patterns

Circuit Breaker

Fail fast on repeated errors
Prevent cascade failures

Retry with Backoff

Transient fault handling
Exponential backoff

Bulkhead

Isolate resources
Limit impact of failures

Detailed patterns and worked examples

Detailed pattern documentation lives in references/details.md. Read that file when the navigation tier above is insufficient.

Files

ATTRIBUTION.mdAdded by AutoGineer1004 B
LICENSELicence file added by AutoGineer1.0 KiB
SKILL.md2.1 KiB
references/details.md14.2 KiB

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Setup TS Deep Modules
Matt Pocock· Community
Configures dependency-cruiser to enforce deep module boundaries in TypeScript repositories.
Software developmentClaude CodeClaude appsOpenAI Codex+14 more
MITLow riskHas scriptsGitHub stars of the source repository317.5k
To Spec
Matt Pocock· Community
Synthesizes conversation context into a structured technical specification and publishes it to a project issue tracker.
Software developmentClaude CodeClaude appsOpenAI Codex+14 more
MITGitHub stars of the source repository317.5k
Improve Codebase Architecture
Matt Pocock· Community
A systematic process to identify, visualize, and refine architectural deepening opportunities in a codebase.
Software developmentClaude CodeClaude appsOpenAI Codex+14 more
MITGitHub stars of the source repository317.5k
Domain Modeling
Matt Pocock· Community
An expert assistant for defining project terminology, maintaining a glossary, and documenting architectural decisions.
Software developmentClaude CodeClaude appsOpenAI Codex+14 more
MITGitHub stars of the source repository317.5k
Codebase Design
Matt Pocock· Community
A shared vocabulary and set of principles for designing deep, testable, and maintainable software modules.
Software developmentClaude CodeClaude appsOpenAI Codex+14 more
MITGitHub stars of the source repository317.5k
Prototype
Matt Pocock· Community
Build a throwaway prototype to answer a design question. Use when the user wants to sanity-check whether a state model or logic feels right, or explore what a UI should look like.
Software developmentClaude CodeClaude appsOpenAI Codex+14 more
MITGitHub stars of the source repository317.5k

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download microservices-patterns.zip