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
Decision gist · record as of 2026-07-14
Microservices Patterns helps you decide whether to decompose a monolith and identify safe extraction points. 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.
Use it when
- microservices-patterns covers essential patterns including API gateways for routing, service discovery (client-side vs.
- microservices-patterns explains saga pattern for coordinating transactions across services without distributed locks.
Verify before relying
Read SKILL.md below before installing (3 files). Open directory: indexed for reading, not audited.
Install
curiositech/some_claude_skills/microservices-patterns · repository language: TypeScript
Open directory. Skills are indexed for reading, not audited. Review a skill's body before installing it.
Frequently 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)
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
Let your AI agent find skills like this
Example. Real query, live index.
You found this page by searching. An agent finds it by wishing: SkillFed indexes 56,283 agent skills by what they can do, searchable in plain language.
wish › “Decide whether to decompose a monolith and where to start”
Give your agent the search over MCP, or paste the wish link into any chat. No install? Search from any chat →
Related skills
Master architectural patterns for building distributed systems through service decomposition, inter-service communication strategies, and fault tolerance techniques. Covers synchronous and asynchronous messaging, database ownership models, and resilience patterns like circuit breakers and bulkheads.
This skill covers foundational architectural approaches for structuring software systems at scale. It walks through monolithic, microservices, event-driven, serverless, clean, and domain-driven architectures—each with use cases, trade-offs, and implementation guidance. A decision tree helps you pick the right pattern based on team size, deployment autonomy, audit requirements, and load variability.
Learn to architect microservices by decomposing monoliths into independent services, managing inter-service communication through synchronous and asynchronous patterns, and implementing resilience strategies like circuit breakers and sagas. This skill covers service decomposition strategies, data management across distributed systems, and practical patterns for building fault-tolerant distributed architectures.
Design and deploy production-ready microservices using Spring Cloud components like service discovery, API Gateway, and load balancing. Learn resilience patterns including circuit breakers, retries, and bulkhead isolation to handle failures gracefully. Implement event-driven communication with Kafka and Spring Cloud Stream, plus observability through distributed tracing and metrics.
This skill guides architects through building cloud-native microservices systems from the ground up. It covers domain-driven service decomposition, communication pattern selection, data ownership strategies, resilience implementation, and observability setup—with concrete code examples for correlation IDs, circuit breakers, sagas, and Kubernetes probes.
Master the fundamentals of building distributed systems through microservices, from domain-driven design and service boundaries to synchronous and asynchronous communication patterns. Explore data consistency strategies, API gateway implementation, and service discovery to architect scalable, independently deployable systems.
More skills microservices-expert (Apache-2.0) · microservices-patterns (MIT) · Microservices Patterns (unlicensed) · code-architecture (MIT)