microservices-patterns
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.
Microservices Patterns teaches you how to decompose monoliths into independently deployable services with clear boundaries.
AI-generated summary based on this skill's SKILL.md
Decision gist · record as of 2026-05-27
Microservices Patterns teaches you how to decompose monoliths into independently deployable services with clear boundaries. 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.
Use it when
- microservices-patterns explains how to identify and establish service boundaries using domain-driven design principles.
- microservices-patterns covers implementing resilience patterns essential for distributed systems.
Verify before relying
Read SKILL.md below before installing (1 file). Open directory: indexed for reading, not audited.
Install
HermeticOrmus/LibreUIUX-Claude-Code/microservices-patterns · repository language: Shell
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 design microservices architecture?
microservices-patterns teaches you to design service boundaries by decomposing monoliths into independently deployable services. Start by identifying domain boundaries, define clear APIs between services, and establish ownership models. The skill covers synchronous (REST, gRPC) and asynchronous messaging approaches, helping you choose communication strategies that fit your system's consistency and latency requirements.
What are microservices service boundaries and decomposition?
microservices-patterns explains how to identify and establish service boundaries using domain-driven design principles. Learn decomposition strategies including the strangler fig pattern for migrating monoliths incrementally. The skill guides you through defining service responsibilities, managing dependencies, and implementing the database-per-service strategy to ensure true service independence and autonomous deployment.
How do I implement circuit breaker and resilience patterns?
microservices-patterns covers implementing resilience patterns essential for distributed systems. Learn circuit breaker pattern to prevent cascading failures, bulkhead pattern for resource isolation, and retry strategies with exponential backoff. These patterns protect your services from transient failures and help maintain system stability when downstream services experience issues or degradation.
How can I build event-driven asynchronous communication?
microservices-patterns teaches event-driven architecture using asynchronous messaging with tools like Kafka and RabbitMQ. Learn to decouple services through event publishing and subscription, implement eventual consistency models, and design event schemas. This approach reduces tight coupling between services and enables better scalability compared to synchronous request-response patterns.
How do I handle distributed transactions with saga pattern?
microservices-patterns explains the saga pattern for managing distributed transactions across multiple services. Learn orchestration and choreography approaches, implement compensation logic for rolling back failed steps, and handle eventual consistency. The skill covers how to coordinate long-running business processes while maintaining data consistency without traditional ACID transactions.
What's the role of API gateway and service discovery?
microservices-patterns covers API gateway patterns for routing client requests, handling cross-cutting concerns like authentication and rate limiting, and providing a unified entry point. Learn service discovery mechanisms for dynamic service registration and load balancing. These infrastructure components enable services to find each other and scale independently in distributed environments.
SKILL.md
Rendered from the published skill. Quoted content, verbatim.
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
(truncated - see the full file via the links below)
File tree — 1 file
plugins/backend-development/skills/microservices-patterns/SKILL.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 › “Design service boundaries and decompose monoliths into microservices”
Give your agent the search over MCP, or paste the wish link into any chat. No install? Search from any chat →
Related skills
This skill covers error handling strategies for building resilient applications across multiple languages. Learn when to use exceptions versus Result types, how to categorize recoverable and unrecoverable errors, and implement patterns like retry with exponential backoff and async error handling. Includes language-specific examples for Python, TypeScript, and Rust.
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.
Get expert guidance on building scalable microservices systems with proven patterns like API Gateway, Circuit Breaker, and Saga for distributed transactions. Learn service discovery, asynchronous messaging, and failure-resilient design principles.
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.
Master the core patterns for building distributed architectures, from decomposing monoliths to implementing resilient inter-service communication. Covers service boundaries organized by business capability, synchronous and asynchronous messaging, and failure-handling techniques like circuit breakers and bulkheads.
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.
More skills Java Microservices (NOASSERTION) · microservices-architecture (MIT) · microservices-architecture (MIT) · Microservices Patterns (unlicensed) · microservices-design (Apache-2.0) · spring-boot-event-driven-patterns (MIT) · architecture-selection (MIT) · architecture (MIT)