Microservices Patterns
SkillMediaThis skill helps an AI agent design microservices architectures. It covers service boundaries, event-driven communication, and resilience patterns, and is meant for building distributed systems, decomposing monoliths, or implementing microservices.
Use Microservices Patterns in Claude, ChatGPT or Ahel Desktop
Free. Sign in, add Microservices Patterns and connect your AI. About a minute.
Also: Claude Code · Cursor · Codex
Then ask your AI: use the Microservices Patterns skill
Details
Instructions available. Your AI can read the instructions. Execution depends on the setup they require.
Account requirements not reviewed. Check the skill instructions before use; ahel provides instructions and does not run this skill.
No other account needed.
Have an AI agent that can load skills and read files from the skill directory.
What your AI can do with it
- Decompose a monolith using business capability, DDD subdomains, or the Strangler Fig
- Choose synchronous REST, gRPC, or GraphQL communication between services
- Choose asynchronous event streaming or message queues such as Kafka, RabbitMQ, or SQS
- Apply database per service and the Saga pattern for distributed data
- Add circuit breakers, retries with backoff, and bulkheads for resilience
- Read references/details.md for deeper pattern documentation and worked examples
Getting started
- Have an AI agent that can load skills and read files from the skill directory.
- Add the microservices-patterns skill to the agent's available skills.
- Describe the system you are building or decomposing, including its current architecture if one exists.
- Ask the agent to apply the skill to your design question, such as service boundaries or communication choices.
- Let the agent read references/details.md when the summary guidance is not enough for your case.
What this skill tells your AI
The instructions your AI receives, as published by wshobson/agents in plugins/backend-development/skills/microservices-patterns/SKILL.md and read by ahel’s review.
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.
Signals
- GitHub stars
- 40k
- Forks
- 4k
- Last commit
- Sep 2026
Others that do the same job
Questions
- What does this skill cover?
- Service decomposition, inter-service communication, distributed data management with patterns like Saga, and resilience techniques such as circuit breakers, retries with backoff, and bulkheads.
- When should I use it?
- When building distributed systems, decomposing monoliths, or implementing microservices, including designing service boundaries and contracts or event-driven architectures.
Advanced
- Item type
- skill
- Key
microservices-patterns-wshobson- Source
- github.com/wshobson/agents