{"enrichment":{"faq":[{"a":"microservices-patterns teaches you to design microservices architecture by establishing clear service boundaries and defining communication contracts. Key patterns include domain-driven design (DDD) bounded contexts for identifying service scope, the strangler fig pattern for gradual migration, and API contracts that specify how services interact. Proper boundaries ensure services are independently deployable and scalable.","q":"What microservices architecture patterns help design proper service boundaries?"},{"a":"microservices-patterns covers service decomposition strategies for breaking monolithic applications into independent microservices. The skill teaches you to identify seams in your codebase, extract bounded contexts, and use the strangler fig pattern to gradually replace monolith functionality with new services. This approach minimizes risk by allowing incremental migration while maintaining system stability.","q":"How do you break up a monolith into microservices?"},{"a":"microservices-patterns explains how to choose between synchronous and asynchronous inter-service communication. Synchronous patterns (REST, gRPC) work well for request-response flows, while asynchronous patterns (event-driven, message queues) suit eventual consistency scenarios. The skill helps you evaluate trade-offs in latency, coupling, and consistency to select the right communication approach for each interaction.","q":"What are microservices communication patterns and when to use each?"},{"a":"microservices-patterns covers the saga pattern for managing distributed transactions and data consistency across services. Sagas coordinate multi-step workflows by orchestrating or choreographing service interactions, ensuring eventual consistency when immediate ACID guarantees aren't possible. This pattern handles failures gracefully through compensating transactions that roll back partial changes.","q":"How does the saga pattern manage data consistency across services?"},{"a":"microservices-patterns teaches resilience patterns including circuit breakers to prevent cascading failures, bulkheads to isolate resources, timeouts for bounded waiting, and retry logic with exponential backoff. These techniques handle failures in distributed systems by detecting problems early, failing fast, and recovering gracefully without bringing down dependent services.","q":"What resilience patterns build fault-tolerant microservices?"},{"a":"microservices-patterns covers event-driven microservices design where services publish domain events and subscribe to events from others, enabling loose coupling and scalability. The skill explains eventual consistency models where services don't require immediate synchronization, using event sourcing and sagas to maintain data coherence across service boundaries over time.","q":"How should microservices handle event-driven architecture and eventual consistency?"}],"shadow_tags":["distributed-systems","service-oriented","fault-tolerance","async-messaging","domain-driven-design","system-decomposition","inter-process-communication","scalability-patterns","transaction-management"],"summary_rewrite":"Learn to architect microservices by decomposing monoliths, defining service boundaries, and choosing between synchronous and asynchronous communication. This skill covers data management strategies like the saga pattern and resilience techniques including circuit breakers and bulkheads to build fault-tolerant distributed systems."},"files":[{"bytes":2125,"path":"plugins/backend-development/skills/microservices-patterns/SKILL.md","sha256":"c9d34026de5eb5b9f730604d1979df9aaa58dd7fa40c022e071da5ca65d68759","url":"https://skillfed.io/files/wshobson/agents/microservices-patterns/50efc3f2/SKILL.md"}],"id":"wshobson/agents/microservices-patterns","links":{"html":"https://skillfed.io/wshobson/agents/microservices-patterns","md":"https://skillfed.io/wshobson/agents/microservices-patterns.md","repo":"https://github.com/wshobson/agents"},"meta":{"agents_supported":[],"first_seen":"2026-07-28","forks":4097,"language":"Python","last_updated":"2026-07-22","license":"MIT","name":"microservices-patterns","publisher":"wshobson","stars":38308},"relations":{"categories":["distributed-systems","software-architecture","backend-engineering"],"similar":[{"id":"secondsky/claude-skills/microservices-patterns"},{"id":"HermeticOrmus/LibreUIUX-Claude-Code/microservices-patterns"},{"id":"eyadsibai/ltk/microservices-patterns"},{"id":"NickCrew/Claude-Cortex/microservices-patterns"},{"id":"Jeffallan/claude-skills/microservices-architect"},{"id":"curiositech/some_claude_skills/microservices-patterns"},{"id":"aj-geddes/useful-ai-prompts/microservices-architecture"},{"id":"vasilyu1983/AI-Agents-public/software-architecture-design"},{"id":"ancoleman/ai-design-components/designing-distributed-systems"},{"id":"travisjneuman/.claude/microservices-architecture"}]},"slug":{"owner":"wshobson","repo":"agents","skill":"microservices-patterns"},"version":"50efc3f2"}