{"enrichment":{"faq":[{"a":"microservices-patterns teaches you to design microservices architecture by identifying clear service boundaries based on business capabilities and domain-driven design principles. The skill covers how to structure services for independence, define communication contracts between services, and establish proper API contracts. You'll learn to balance service granularity\u2014avoiding both overly coarse services that retain monolithic coupling and overly fine services that create excessive inter-service chatter.","q":"How do you design microservices architecture with proper service boundaries?"},{"a":"microservices-patterns emphasizes implementing resilience patterns including circuit breakers, retries, timeouts, and bulkheads to handle service failures gracefully. Circuit breakers prevent cascading failures by stopping requests to failing services, while retry logic with exponential backoff handles transient failures. The skill teaches you to combine these patterns to build fault-tolerant systems that degrade gracefully when individual services fail.","q":"What resilience patterns does microservices-patterns cover for handling failures?"},{"a":"microservices-patterns provides strategies for decomposing monolithic applications into independent microservices using approaches like the strangler fig pattern, which gradually replaces monolith functionality with new services. The skill covers identifying service boundaries, managing data migration, handling inter-service dependencies, and coordinating the transition without disrupting existing operations. You'll learn to prioritize which components to extract first based on business value and technical dependencies.","q":"How can you decompose a monolithic application into microservices?"},{"a":"microservices-patterns explains the saga pattern for coordinating distributed transactions across multiple microservices without traditional ACID guarantees. Sagas use either choreography (services listen to events and trigger next steps) or orchestration (a coordinator service manages the transaction flow). The skill teaches you to handle compensating transactions for rollback scenarios and manage eventual consistency when operations span multiple independent services.","q":"What is the saga pattern and how does it coordinate distributed transactions?"},{"a":"microservices-patterns covers event-driven communication as an asynchronous pattern where services publish events that other services consume, enabling loose coupling and scalability. The skill addresses event streaming platforms, message brokers, and event schema management. You'll learn when to use event-driven patterns versus synchronous communication, how to ensure reliable event delivery, and strategies for managing event ordering and idempotency across distributed services.","q":"How does event-driven communication work in microservices systems?"},{"a":"microservices-patterns teaches the database-per-service pattern where each microservice manages its own data store, ensuring service independence and technology flexibility. The skill covers managing data consistency across services through eventual consistency models, handling distributed queries, and coordinating data changes across service boundaries. You'll learn trade-offs between data isolation and consistency, and patterns for sharing data between services safely.","q":"What data management strategies does microservices-patterns recommend?"}],"shadow_tags":["distributed-systems","service-architecture","fault-tolerance","async-messaging","system-decomposition","inter-process-communication","transaction-coordination","service-resilience","architectural-patterns","system-integration"],"summary_rewrite":"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."},"files":[{"bytes":10695,"path":"plugins/microservices-patterns/skills/microservices-patterns/SKILL.md","sha256":"1bbe5d2c8f17d115b841d8e732b7e806ee3e3e71e4da6bf9e65e5d3caf254eba","url":"https://skillfed.io/files/secondsky/claude-skills/microservices-patterns/02a96b3f/SKILL.md"}],"id":"secondsky/claude-skills/microservices-patterns","links":{"html":"https://skillfed.io/secondsky/claude-skills/microservices-patterns","md":"https://skillfed.io/secondsky/claude-skills/microservices-patterns.md","repo":"https://github.com/secondsky/claude-skills"},"meta":{"agents_supported":[],"first_seen":"2026-07-28","forks":29,"language":"TypeScript","last_updated":"2026-07-25","license":"MIT","name":"microservices-patterns","publisher":"secondsky","stars":196},"relations":{"categories":["distributed-systems","software-architecture","backend-engineering"],"similar":[{"id":"HermeticOrmus/LibreUIUX-Claude-Code/microservices-patterns"},{"id":"personamanagmentlayer/pcl/microservices-expert"},{"id":"eyadsibai/ltk/microservices-patterns"},{"id":"organvm/a-i--skills/resilience-patterns"},{"id":"personamanagmentlayer/pcl/design-expert"},{"id":"eyadsibai/ltk/saga-orchestration"},{"id":"HermeticOrmus/LibreUIUX-Claude-Code/error-handling-patterns"},{"id":"BagelHole/DevOps-Security-Agent-Skills/ai-agent-security"},{"id":"josavicentevw/ai-agent-skills/architecture"},{"id":"manutej/luxor-claude-marketplace/asyncio-concurrency-patterns"}]},"slug":{"owner":"secondsky","repo":"claude-skills","skill":"microservices-patterns"},"version":"02a96b3f"}