microservices-patterns
- Use it when:
- You're splitting a monolith into services, drawing service boundaries, or designing how services talk to each other and survive each other's failures.
- It does:
- Gives the agent patterns for cutting services, calling them directly or through events, giving each its own data, and staying up when one fails.
- You get:
- Designs along those patterns; it adds no steps or files of its own, and a reference file holds Python examples.
- Terms:
- A saga is a chain of local transactions with compensating undo steps; a circuit breaker stops calling a failing service for a while.
TL;DR
A reference, not a workflow. It names three ways to cut services: by business capability (orders, payments, inventory), by subdomain, where each bounded context from domain-driven design becomes a service, and the strangler fig pattern, which moves features out of a monolith gradually behind a proxy. Services talk synchronously over REST, gRPC or GraphQL, or asynchronously through Kafka, RabbitMQ or SQS. Each service owns its database, and transactions that span services become sagas with eventual consistency. Resilience comes from circuit breakers, retries with exponential backoff and bulkheads, which isolate resources so one failure stays contained. The reference file shows each in Python: services that publish events, a FastAPI gateway that combines several services' data behind circuit breakers and tolerates partial failures, an HTTP client with retries and timeouts, an event bus on Kafka, an order-fulfillment saga that runs compensations when a step fails, and a circuit breaker class with closed, open and half-open states.
Summarizes the skill at 4bde316.
npx skills add https://github.com/wshobson/agents --skill microservices-patterns skills.sh pageSource on GitHubAll skills from wshobson/agents
- Total Downloads
- 13,700 on skills.sh, Nov 9, 2026
- Repo stars
- 42,334 wshobson/agents
- First seen
- Jan 20, 2026 on skills.sh
Weekly values
| Week to | Installs |
|---|---|
| Sep 21 | 212 |
| Sep 28 | 254 |
| Oct 5 | 295 |
| Oct 12 | 249 |
| Oct 19 | 219 |
| Oct 26 | 222 |
| Nov 2 | 232 |
| Nov 9 | 183 |
| Category |
Test-first work, implementation from specs, git hygiene and scope control. Everything for building software: planning, coding, debugging, design, frameworks, cloud, agents and skills. |
|---|---|
| Type |
Knowledge and rules the agent applies while it works: best practices, design principles, API references. |
| Effect |
Adds no side effects of its own. It shapes how the agent thinks, writes or reviews. Guidelines and routers are always effect:none, even when the task they support edits code. |
| Needs |
Instructions only. Works in any agent that supports skills. |
| Publisher |
Everyone else. Unverified vendor claims default to community. |
| Topics |
SKILL.md
From wshobson/agents at 4bde316. Checked daily, last changed Nov 6, 2026.
Frontmatter
name: microservices-patterns
description: Design microservices architectures with service boundaries, event-driven communication, and resilience patterns. Use when building distributed systems, decomposing monoliths, or implementing microservices.Microservices Patterns
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.