{"enrichment":{"faq":[{"a":"microservices-patterns provides comprehensive guidance on decomposing monoliths into independent services. Start by identifying service boundaries based on business capabilities and domain-driven design principles. The skill covers service decomposition strategies, API contracts, and patterns for organizing teams around service ownership. Key considerations include managing data consistency, defining clear responsibilities, and planning migration paths from monolithic to distributed architectures.","q":"How do I design microservices architecture and break down monolithic applications into services?"},{"a":"microservices-patterns explains both synchronous and asynchronous communication approaches. Synchronous patterns use direct service-to-service calls via REST or gRPC, while asynchronous patterns leverage message queues and event-driven architectures. The skill covers service discovery, API gateways, and inter-service communication best practices. It also addresses trade-offs between consistency, latency, and coupling to help you choose the right pattern for each interaction.","q":"What are the main microservices communication patterns for sync and async interactions?"},{"a":"microservices-patterns guides you through implementing resilient inter-service communication and failure handling. The circuit breaker pattern prevents cascading failures by monitoring service health and failing fast when issues occur. The skill covers retry strategies, backoff mechanisms, timeouts, and bulkhead isolation. It teaches how to design fault-tolerant distributed systems that gracefully degrade when services fail, maintaining system stability across your microservices ecosystem.","q":"How can I implement the circuit breaker pattern and build resilient microservices?"},{"a":"microservices-patterns addresses the database-per-service pattern and distributed transaction challenges. It covers the saga pattern for coordinating multi-step transactions across services, both orchestration and choreography approaches. The skill explains eventual consistency models, compensating transactions, and strategies for maintaining data integrity without distributed locks. You'll learn how to design systems that handle partial failures and ensure consistency across service boundaries.","q":"What patterns manage data consistency and transactions across distributed microservices?"},{"a":"microservices-patterns covers comprehensive observability strategies for distributed systems. It guides you through implementing distributed tracing to track requests across services, centralized logging for debugging, and metrics collection for monitoring system health. The skill explains service mesh setup, API gateway configuration, and tools for gaining visibility into inter-service communication. Observability enables you to diagnose issues quickly and understand system behavior in production.","q":"How do I add observability, tracing, logging, and metrics to microservices systems?"},{"a":"microservices-patterns provides deployment strategies and migration planning guidance for transitioning from monolithic to distributed architectures. It covers phased migration approaches, strangler pattern implementation, and deployment orchestration. The skill addresses service versioning, backward compatibility, and rollout strategies. It also highlights common microservices anti-patterns and mistakes to avoid, helping you execute migrations successfully while maintaining system stability and minimizing disruption.","q":"What are the best practices for microservices deployment and monolith-to-microservices migration?"}],"shadow_tags":["distributed-architecture","system-decomposition","fault-tolerance","service-orchestration","async-messaging","deployment-strategy","observability-stack","domain-driven-design","network-resilience","architectural-patterns"],"summary_rewrite":"Expert guidance for architecting and operating microservices, from breaking down monoliths to managing inter-service communication and data consistency. Covers service boundaries, synchronous and asynchronous patterns, distributed transactions, circuit breakers, and observability strategies."},"files":[{"bytes":4104,"path":"skills/microservices-patterns/SKILL.md","sha256":"274cd867d263f3912c330c1f68ff43e2ac8c4f9effe893fc6ccc7dc12f9e3ff0","url":"https://skillfed.io/files/NickCrew/Claude-Cortex/microservices-patterns/1191e3a2/SKILL.md"}],"id":"NickCrew/Claude-Cortex/microservices-patterns","links":{"html":"https://skillfed.io/NickCrew/Claude-Cortex/microservices-patterns","md":"https://skillfed.io/NickCrew/Claude-Cortex/microservices-patterns.md","repo":"https://github.com/NickCrew/Claude-Cortex"},"meta":{"agents_supported":[],"first_seen":"2026-07-28","forks":13,"language":"Python","last_updated":"2026-06-29","license":"MIT","name":"microservices-patterns","publisher":"NickCrew","stars":23},"relations":{"categories":["distributed-systems","software-architecture","devops"],"similar":[{"id":"HermeticOrmus/LibreUIUX-Claude-Code/microservices-patterns"},{"id":"secondsky/claude-skills/microservices-patterns"},{"id":"eyadsibai/ltk/microservices-patterns"},{"id":"wshobson/agents/microservices-patterns"},{"id":"NickCrew/Claude-Cortex/api-gateway-patterns"},{"id":"Jeffallan/claude-skills/microservices-architect"},{"id":"aj-geddes/useful-ai-prompts/microservices-architecture"},{"id":"ancoleman/ai-design-components/designing-distributed-systems"},{"id":"NickCrew/Claude-Cortex/incident-response"},{"id":"manutej/luxor-claude-marketplace/microservices-patterns"}]},"slug":{"owner":"NickCrew","repo":"Claude-Cortex","skill":"microservices-patterns"},"version":"1191e3a2"}