microservices-patterns
Master the decision to decompose systems into independent services and the patterns that keep them reliable. Covers bounded contexts, strangler fig extraction, synchronous vs. asynchronous communication, circuit breakers, saga patterns, and event sourcing—helping you avoid distributed monoliths and operational chaos.
Microservices Patterns helps you decide whether to decompose a monolith and identify safe extraction points.
AI-generated summary based on this skill's SKILL.md
Install
curiositech/some_claude_skills/microservices-patterns · repository language: TypeScript
git clone https://github.com/curiositech/some_claude_skills
cp -r some_claude_skills/.claude/skills/microservices-patterns ~/.claude/skills/microservices-patternsnpx skillfed install curiositech/some_claude_skills/microservices-patternsFrequently asked questions
AI-generated answers based on this skill's SKILL.md and metadata
How do I decompose a monolith into microservices?
microservices-patterns guides you through monolith decomposition by starting with bounded contexts—identifying natural service boundaries aligned to business capabilities. The skill covers the strangler fig pattern for gradual extraction, helping you avoid the distributed monolith anti-pattern. Begin by analyzing data ownership and service responsibilities, then incrementally route traffic to new services while keeping the legacy system operational.
What are the key microservices architecture patterns?
microservices-patterns covers essential patterns including API gateways for routing, service discovery (client-side vs. server-side), and communication strategies (REST vs. gRPC). It addresses resilience patterns like circuit breakers and bulkheads for fault isolation, saga patterns for distributed transactions, and event-driven architectures. You'll also learn CQRS and event sourcing design tradeoffs, plus backend-for-frontend (BFF) patterns for client-specific APIs.
How does the saga pattern handle distributed transactions?
microservices-patterns explains saga pattern for coordinating transactions across services without distributed locks. It covers two approaches: orchestration (a central coordinator directs steps) and choreography (services react to events). The skill helps you choose between them based on complexity and observability needs, and shows how to handle compensating transactions when failures occur, keeping your system consistent without tight coupling.
What resilience patterns protect microservices from failure?
microservices-patterns teaches circuit breaker and bulkhead patterns to prevent cascading failures. Circuit breakers stop requests to failing services, while bulkheads isolate resources to contain damage. The skill covers when and how to apply these patterns, service mesh integration for transparent resilience, and designing for graceful degradation. These patterns keep your system stable even when individual services experience issues.
When should I use event sourcing and CQRS?
microservices-patterns explores CQRS (Command Query Responsibility Segregation) and event sourcing design tradeoffs. Event sourcing stores state changes as immutable events, enabling audit logs and temporal queries but adding complexity. CQRS separates read and write models for optimization. The skill helps you decide if these patterns fit your consistency, scalability, and auditability requirements, or if simpler approaches suffice.
Should I decompose my system or keep it as a monolith?
microservices-patterns helps you decide by weighing team structure, deployment frequency, and scaling needs against operational complexity. Monoliths suit small teams and simple domains; microservices enable independent scaling and deployment but introduce distributed system challenges. The skill teaches you to recognize when you're ready—typically when bounded contexts are clear, teams are distributed, or scaling needs differ across components.
SKILL.md
rendered from the published skill — quoted content, verbatim
name: microservices-patterns description: Microservice architecture patterns — service decomposition, inter-service communication, API gateway, saga pattern, event-driven architecture, service mesh, circuit breaker, CQRS, event sourcing. Activate on "microservices", "service decomposition", "saga pattern", "API gateway", "event-driven", "service mesh", "circuit breaker", "CQRS", "event sourcing", "bounded context", "strangler fig", "distributed transactions", "choreography vs orchestration". NOT for monolith design, serverless functions, or Kubernetes infrastructure. allowed-tools: Read,Write,Edit,Bash,Grep,Glob metadata: category: DevOps & Site Reliability tags: - microservices - patterns - service-decomposition - saga-pattern pairs-with: - skill: api-architect reason: Inter-service communication design (REST, gRPC, events) is core to microservice architecture - skill: docker-containerization reason: Each microservice is typically containerized and independently deployable - skill: code-architecture reason: Service internal architecture patterns (hexagonal, clean) apply within each microservice - skill: background-job-orchestrator
(truncated - see the full file via the links below)
Read as markdown · JSON record · Browse the source repository
File tree — 3 files
.claude/skills/microservices-patterns/SKILL.md
.claude/skills/microservices-patterns/references/communication-patterns.md
.claude/skills/microservices-patterns/references/decomposition-strategies.md