Enterprise Architecture Patterns

🏛️ Enterprise Architecture Patterns to Use

1. Layered Architecture Pattern

• Use When: Structuring applications and platforms with clear separation of concerns.

• Layers:

  • Presentation Layer (UI)

  • Application Layer (Services)

  • Domain/Business Logic Layer

  • Data Access Layer

  • Infrastructure Layer (DB, Cloud, Network)

Helps enforce modularity, simplifies testing and future changes.

2. Domain-Driven Design (DDD)

• Use When: Modeling complex enterprise domains.

• Components:

  • Bounded Contexts

  • Aggregates, Entities, Value Objects

  • Ubiquitous Language

Allows aligning tech with business, decouples domains, and guides microservice boundaries.

3. Service-Oriented Architecture (SOA)

• Use When: You need service reusability across multiple domains or systems.

• Key Features:

  • Loosely coupled services

  • Service contracts

  • Enterprise Service Bus (ESB)

Promotes reuse and interoperability; often a precursor to microservices.

4. Microservices Architecture Pattern

• Use When: Building highly scalable, loosely coupled, and independently deployable services.

• Key Traits:

  • Service per business capability

  • Own data per service

  • API-first communication (REST/gRPC)

Encourages agility and team autonomy.

5. Event-Driven Architecture (EDA)

• Use When: Systems need to respond to events in real-time, especially in asynchronous, decoupled environments.

• Components:

  • Event Producers & Consumers

  • Event Bus/Broker (Kafka, RabbitMQ)

  • Event Store

Enables loosely coupled integrations and reactive systems.

6. Command Query Responsibility Segregation (CQRS)

• Use When: You need to scale read and write workloads independently.

• Split:

  • Commands: mutate state

  • Queries: read-only

Works well with Event Sourcing; used in high-throughput systems.

7. Strangler Fig Pattern

• Use When: Modernizing legacy systems gradually.

• Approach:

  • Create new functionality around legacy system

  • Slowly replace and retire legacy components

Reduces risk in large digital transformation projects.

8. API Gateway Pattern

• Use When: Managing internal/external APIs at scale.

• Benefits:

  • Single point for authentication, rate-limiting, transformation

  • Backend service abstraction

Central for microservices, platform, and integration architectures.

9. Shared Kernel Pattern (from DDD)

• Use When: Two teams/services need to share a common domain model but remain decoupled otherwise.

Encourages collaboration while avoiding tight coupling.

10. Zero Trust Security Pattern

• Use When: Designing enterprise-wide secure architecture.

• Principles:

  • Never trust, always verify

  • Micro-segmentation

  • Least privilege access

Vital for cloud-native, hybrid, or multi-tenant architectures.

11. Data Mesh Pattern

• Use When: Scaling data ownership across domains.

• Core Concepts:

  • Data-as-a-product

  • Domain ownership

  • Federated governance

Useful for large, distributed enterprise data ecosystems.

12. Portfolio Architecture Pattern

• Use When: Managing multiple business capabilities and platforms.

• Approach:

  • Group by domain/portfolio

  • Assign ownership and governance per portfolio

  • Cross-portfolio integration using APIs/events

Enables decentralized architecture governance at scale.

🔧 Additional Considerations

• Governance Patterns: Architecture Review Boards (ARBs), EA repositories (LeanIX, ArchiMate)

• Integration Patterns: Pub/Sub, File Transfer, Shared DB, Sync/Async APIs

• Deployment Patterns: Blue-Green, Canary, Rolling Updates

• Observability Patterns: Centralized logging, tracing, dashboards