New to Claude Skills? Learn how to install them →

wshobson on GitHub

Microservices Patterns

Free

Design robust microservices architectures with proven patterns.

by wshobson38.7k stars on wshobson/agents
3 views
Updated Jul 18, 2026
Get this skill

Free · Opens the source repo

What Microservices Patterns does

Microservices Patterns is a comprehensive guide for developers and architects looking to implement microservices architectures effectively. This skill provides detailed instructions on how to design service boundaries, manage inter-service communication, and ensure resilience in distributed systems. It is particularly useful for those transitioning from monolithic applications to microservices, as it outlines clear strategies for service decomposition and data management.

The skill covers essential concepts such as organizing services by business capability or subdomain, employing the Strangler Fig Pattern for gradual migration, and implementing various communication patterns like REST APIs and event-driven architectures. It also addresses critical aspects of data management, advocating for a database-per-service approach and introducing the Saga Pattern for handling distributed transactions. These foundational elements are crucial for maintaining loose coupling and ensuring that each service can independently manage its data.

In addition to architectural strategies, the skill emphasizes resilience patterns that are vital for building robust systems. Techniques like Circuit Breaker, Retry with Backoff, and Bulkhead are discussed, providing developers with the tools needed to handle failures gracefully and maintain system stability. By leveraging these patterns, teams can create microservices that are not only functional but also resilient to common issues encountered in distributed environments.

This skill is designed for software engineers, system architects, and technical leads who are involved in the design and implementation of microservices. It serves as a valuable resource for anyone looking to deepen their understanding of microservices architecture and apply best practices in real-world scenarios.

When to use it

Use this skill when you need to decompose a monolithic application into microservices or when designing new microservices from scratch.

When not to use it

This skill may not be suitable for projects that do not require a microservices architecture or for teams unfamiliar with distributed systems concepts.

What you can build with it

Transitioning from Monolith to Microservices

Utilize the skill to plan and execute the gradual decomposition of a monolithic application into microservices, ensuring a smooth transition.

Designing Event-Driven Systems

Leverage the communication patterns outlined in this skill to create an event-driven architecture that enhances system responsiveness and scalability.

Implementing Resilience in Distributed Systems

Apply the resilience patterns discussed to build robust microservices that can withstand failures and maintain service availability.

How to install Microservices Patterns

View source

1. Install with the skills CLI

npx skills add wshobson/agents/microservices-patterns --agent claude-code

2. Or install it manually

Download the skill folder and drop it into ~/.claude/skills/ for all projects, or .claude/skills/ to scope it to one repo. Restart Claude Code so it picks up the new skill.

Anthropic's agentic coding CLI, and the reference implementation of Agent Skills. Drop a skill folder into ~/.claude/skills and Claude Code loads it automatically whenever a task matches the skill's description. Claude Code docs

Inside SKILL.md

Written by wshobson

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.

Frequently asked questions about Microservices Patterns

Similar skills