microservice-architect

Plan microservice architectures with domain-driven design and service boundaries.

Updated Dec 24, 2025
One-click install
npx skills add https://github.com/yairbederman/EngineeringAgency --skill microservice-architect
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: microservice-architect
Source: https://github.com/yairbederman/EngineeringAgency/tree/main/skills/microservice-architect
Command: npx skills add https://github.com/yairbederman/EngineeringAgency --skill microservice-architect

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Guides teams to plan and define microservice boundaries and interfaces to enable scalable, maintainable architectures.

Core Features & Use Cases

  • Identify bounded contexts and map service boundaries using domain-driven design.
  • Compare synchronous, asynchronous, and event-driven communication patterns and describe per-service data ownership.
  • Produce an architectural plan with proposed services, interfaces, data ownership, deployment considerations, and a rationale for boundaries.

Quick Start

Describe your domain and let the AI propose bounded contexts, service interfaces, and an initial deployment outline.

Frequently Asked Questions about microservice-architect

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I define microservice boundaries using domain-driven design?

Microservice boundaries are defined by identifying bounded contexts within your domain to ensure per-service data ownership. Mapping these contexts allows you to group related domain logic and clearly separate service responsibilities for scalable architecture.

What is the best way to decompose a monolith into microservices?

Decomposing a monolith involves evaluating service ownership across domains and enforcing per-service data ownership. You map bounded contexts to propose new services, define their interfaces, and establish an architectural plan with a clear rationale for the boundaries.

When should I use the saga pattern in microservice architectures?

The saga pattern is used in microservice architectures to manage distributed transactions and maintain data consistency across services. It is recommended when enforcing event-driven communication and replacing traditional synchronous database transactions across bounded contexts.

How do I choose between synchronous and event-driven communication patterns for microservices?

Choosing communication patterns involves comparing synchronous, asynchronous, and event-driven approaches based on your service interfaces and data ownership requirements. The architectural plan evaluates these options to recommend the most suitable pattern for your specific domain interactions.

Can I plan deployment considerations for new microservices from scratch?

Yes, planning new microservice systems includes producing an architectural plan with proposed services, interfaces, and deployment considerations. You provide a domain description to generate an initial deployment outline and rationale for the chosen service boundaries.

Why enforce per-service data ownership in a microservices architecture?

Per-service data ownership is enforced in microservices to ensure loose coupling and maintain bounded contexts. It prevents services from sharing databases directly, requiring them to communicate through defined interfaces or event-driven patterns like CQRS and saga.