enterprise-architecture-patterns_skill

Overview

This skill is a complete guide to enterprise architecture patterns for building scalable, maintainable, and resilient systems. It focuses on domain-driven design, event sourcing, CQRS, saga patterns, API gateways, service mesh, and scaling strategies. Content is practical and oriented to engineers designing distributed, cloud-native, or microservices architectures.

How this skill works

The skill explains core concepts, tactical and strategic DDD patterns, and concrete implementations for aggregates, entities, value objects, domain events, and repositories. It covers integration patterns (API Gateway, service mesh), distributed transaction patterns (sagas), and event-driven techniques (event sourcing, CQRS) with guidance on consistency, scalability, and fault tolerance. Each pattern includes when to apply it, benefits, trade-offs, and concise implementation examples.

When to use it

• Designing microservices or decomposing a monolith
• Implementing domain-driven design for complex business domains
• Building event-driven systems with event sourcing and CQRS
• Coordinating distributed transactions using saga patterns
• Deploying API gateways or a service mesh for cross-cutting concerns and observability

Best practices

• Model bounded contexts around business capabilities and use a ubiquitous language consistently
• Keep aggregates small; enforce invariants at the aggregate root and reference others by ID
• Prefer immutable domain events named in past tense and include necessary context
• Use eventual consistency deliberately and document the user-facing implications
• Design clear integration contracts (Open Host Service, Published Language) and protect legacy systems with an Anti-Corruption Layer

Example use cases

• E-commerce platform: separate Sales, Billing, and Inventory bounded contexts with event-driven synchronization
• Payment flows: use sagas to orchestrate distributed payment, inventory, and notification services
• High-throughput analytics: use CQRS to separate write model (event store) from optimized read models
• API consolidation: front microservices with an API gateway and enforce auth, rate limiting, and routing
• Cloud-native scaling: combine horizontal scaling, service mesh for resilient inter-service communication, and partitioned data stores