ddd-decomposition

Identify bounded contexts and service boundaries for multi-tenant Go microservices.

1|Updated Apr 17, 2026
One-click install
npx skills add https://github.com/PremModhaOfficial/motadata-ai-pipeline --skill ddd-decomposition
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ddd-decomposition
Source: https://github.com/PremModhaOfficial/motadata-ai-pipeline/tree/main/.claude/skills/ddd-decomposition
Command: npx skills add https://github.com/PremModhaOfficial/motadata-ai-pipeline --skill ddd-decomposition

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Domain complexity often leads to unclear boundaries, coupling, and brittle deployments across multi-tenant Go microservices. This skill provides a structured approach to identify bounded contexts, select aggregate roots, and create context maps that align with business capabilities. It also offers a decision framework to choose between a shared kernel and an anti-corruption layer, ensuring clean boundaries in AWS EKS, PostgreSQL 18 and NATS JetStream environments.

Core Features & Use Cases

  • Bounded context discovery: Systematically identify and document bounded contexts aligned to business capabilities.
  • Context maps and ownership: Produce explicit maps showing domain ownership and interaction styles between contexts.
  • Aggregate root selection & ACL decisions: Guidance for selecting aggregate roots and deciding between shared kernel and ACL to minimize cross-context coupling.
  • Deployment-ready guidance: Produces boundary definitions compatible with multi-tenant AWS EKS deployments and NATS JetStream messaging.

Quick Start

Identify initial bounded contexts and boundary candidates for your multi-tenant Go services.

Frequently Asked Questions about ddd-decomposition

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

FAQPage Schema
How do I identify bounded contexts for a multi-tenant Go microservice platform?

Identify bounded contexts by systematically analyzing domain capabilities to produce explicit context maps and service boundaries for multi-tenant Go microservices. This decomposition aligns services with business capabilities and defines clear domain ownership.

When do I need an anti-corruption layer vs a shared kernel in domain-driven design?

You need an anti-corruption layer to minimize cross-context coupling when integrating complex domains, while a shared kernel suits scenarios requiring tighter integration. This skill provides a decision framework to choose between them for clean microservice boundaries.

What's the best way to map aggregate roots in a multi-tenant microservices architecture?

The best way to map aggregate roots is applying structured domain-driven design decomposition to select roots that enforce transactional consistency within bounded contexts. This yields explicit aggregate definitions compatible with your multi-tenant architecture.

Can I use DDD decomposition for AWS EKS and NATS JetStream deployments?

Yes, DDD decomposition applies directly to AWS EKS and NATS JetStream deployments. It produces deployment-ready service boundary frameworks and context maps tailored for multi-tenant environments using PostgreSQL and NATS JetStream messaging.

How do I create a context map for multi-tenant Go services?

Create a context map by documenting bounded contexts and their interaction styles to establish domain ownership across multi-tenant Go services. This process outputs explicit maps showing how different service boundaries communicate and integrate.

Why does domain complexity cause brittle deployments in multi-tenant microservices?

Domain complexity causes brittle deployments when unclear boundaries and hidden coupling exist between multi-tenant microservices. Applying bounded context discovery and aggregate root selection resolves this by aligning service boundaries with true business capabilities.