microservices-architect

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.

Microservices Architect helps you design distributed system architectures and decompose monoliths into independently deployable services.

AI-generated summary based on this skill's SKILL.md

★ 10,759 ⁮ 984 MIT updated 2026-05-20 by Jeffallan

Install

Jeffallan/claude-skills/microservices-architect · repository language: Python

Manual (git clone) CLI (skillfed)

git clone https://github.com/Jeffallan/claude-skills
cp -r claude-skills/skills/microservices-architect ~/.claude/skills/microservices-architect

npx skillfed install Jeffallan/claude-skills/microservices-architect

Frequently asked questions

AI-generated answers based on this skill's SKILL.md and metadata

How do I design a microservices architecture for a new distributed system?

microservices-architect guides you through building cloud-native systems by starting with domain-driven design to identify service boundaries and bounded contexts. Begin by mapping your business domain, then decompose it into loosely coupled services. Define clear APIs (REST or gRPC), establish data ownership with a database-per-service strategy, and plan your communication patterns—synchronous for tight coupling needs, asynchronous (Kafka, RabbitMQ) for eventual consistency. The skill provides concrete code examples for each phase.

What's the best way to decompose a monolith into microservices?

microservices-architect recommends applying domain-driven design to identify natural service boundaries before splitting. Map your domain's bounded contexts to candidate services, then refactor incrementally—extract one service at a time to minimize risk. Plan your database strategy (separate databases per service), choose communication patterns (REST, gRPC, or events), and implement resilience patterns like circuit breakers. The skill includes examples for correlation IDs, saga patterns for distributed transactions, and health probes for Kubernetes deployment.

How should microservices communicate—REST, gRPC, or messaging?

microservices-architect covers communication pattern selection based on your needs. Use synchronous REST or gRPC for request-response flows where you need immediate answers; choose asynchronous messaging (Kafka, RabbitMQ) for event-driven architectures and eventual consistency. Implement resilience strategies like circuit breakers, timeouts, and retries for all patterns. The skill provides implementation guidance for each, including correlation IDs for distributed tracing to track requests across services.

What resilience patterns should I implement for fault tolerance?

microservices-architect teaches key resilience patterns: circuit breakers prevent cascading failures, timeouts stop hanging requests, and retries with exponential backoff handle transient errors. For distributed transactions, use the saga pattern (orchestration or choreography). Implement distributed tracing with correlation IDs to track requests end-to-end. Add health checks and readiness probes in Kubernetes to detect and replace failing instances. Event sourcing and CQRS patterns support eventual consistency and audit trails.

How do I set up observability and monitoring for microservices?

microservices-architect guides distributed tracing, logging, and metrics collection across services. Use correlation IDs to link requests across service boundaries, enabling end-to-end visibility. Implement health checks and readiness probes for Kubernetes to monitor service health. Consider a service mesh (Istio) for advanced observability, traffic management, and fault injection. Combine logs, traces, and metrics to detect issues early and understand system behavior under load.

What deployment strategy works best for microservices?

microservices-architect recommends container orchestration (Kubernetes) with service mesh (Istio) for production deployments. Use health probes (liveness and readiness) to ensure only healthy instances receive traffic. Plan your API gateway strategy for external access and service mesh for internal communication, traffic management, and security policies. Implement gradual rollouts and canary deployments to minimize risk. Combine these with distributed tracing and observability to maintain system reliability.

SKILL.md

rendered from the published skill — quoted content, verbatim