Realm
Architecture Practices
Named practices interpreted as cross-realm bundles of problems, constraints, and realization choices.
Entries
Actor Model
The actor model addresses the problem of organizing concurrent computation around isolated, addressable participants that communicate by message passing.
Analysis Patterns
Analysis Patterns, by Martin Fowler, collects reusable structures discovered while modeling domains such as health care, financial trading, accounting, and organizational relationships.
Anti-Corruption Layer
An anti-corruption layer addresses the problem of integrating with another model without letting that model's semantics leak into the local boundary.
Architecture Practices
Architecture practices are named bundles of modeling choices, constraints, and implementation habits that address recurring system-engineering problems.
Asynchronous Interaction Design
Asynchronous interaction design is the architecture practice of making independently progressing work explicit when one interaction is split across time, participants, and commit boundaries.
Capacity Planning
Capacity planning is an architecture and operational practice for relating expected demand, service-level objectives, failure assumptions, and provisioning lead times to the effective capacity and reserve a system must have available.
Clean Architecture
Clean Architecture addresses the problem of dependency direction: keeping high-value semantic rules from depending on volatile delivery, persistence, framework, and infrastructure choices.
CQRS as Architecture Practice
CQRS, command query responsibility segregation, is an architecture-practice bundle that deliberately gives command interpretation and query observation different models, responsibilities, and operational paths when their forces differ materially.
CRDTs as Architecture Practice
CRDTs are a distributed-systems practice for designing replicated state that can accept concurrent updates and converge without synchronous coordination for every update.
Data Mesh
Data Mesh addresses the problem of scaling analytical and operational data ownership across organizational and domain boundaries.
Domain-Driven Design
Domain-Driven Design, or DDD, addresses the problem of preserving domain meaning in software as systems grow in complexity.
Durable Execution
Durable execution is an architecture practice for keeping a logical execution coherent across failure, restart, suspension, timeout, or delayed external work.
Enterprise Integration Patterns
Enterprise Integration Patterns, or EIP, is a technology-independent pattern language for message-based integration. Cohesive uses the catalog as an important architecture vocabulary while preserving the distinction among domain semantics, system-graph structure, operational concerns, architecture practices, and realization substrate.
Event Sourcing as Architecture Practice
Event sourcing is often described as an architecture practice. In the Cohesive System Model, the technical mechanics are captured by event sourcing as a realization substrate pattern.
Event-Driven Architecture
Event-Driven Architecture addresses the problem of coordinating independent participants through event flow rather than direct synchronous control.
Microservice Architecture
Microservice architecture addresses the problem of independent ownership, deployment, scaling, and evolution across bounded capabilities. These benefits are not exclusive to microservices: a modular monolith can establish similar semantic and code boundaries and can selectively separate deployment or scaling units. The prefix *micro* is relative to a coarser service, application, or deployment boundary; it does not prescribe a code size, endpoint count, process count, or team size.
Microservice Pattern Language
The microservice pattern language collects architecture-practice patterns that allocate semantic responsibility and authority to independently evolvable services, connect them in service models through provided and required interfaces, govern their conversations with interaction protocols, state their operational guarantees, and select realization mechanisms. It covers decomposition, collaboration, data ownership, transactional messaging, communication, deployment, discovery, reliability, security, observability, testing, and migration.
Modular Monolith
The modular monolith addresses the problem of maintaining strong internal boundaries and cohesive change units within one repository and one compiler-visible solution or build graph. The shared graph enables static contract checking, compiler-enforced dependency rules, coordinated refactoring, shared code, and common repository and delivery infrastructure across the modules.
Orchestration and Choreography
Orchestration and choreography are forms of coordination distinguished primarily by where control of a coherent process resides.
Pattern-Oriented Software Architecture
Pattern-Oriented Software Architecture, or POSA, is a multi-volume system of architectural patterns, design patterns, idioms, concurrency and networking patterns, resource-management patterns, and a composed pattern language for distributed computing.
Patterns of Distributed Systems
Patterns of Distributed Systems, by Unmesh Joshi, collects recurring implementation structures used in distributed storage, messaging, system management, and compute infrastructure.
Patterns of Enterprise Application Architecture
Patterns of Enterprise Application Architecture, or PoEAA, catalogs recurring structures for domain logic, application boundaries, relational persistence, web presentation, distribution, offline concurrency, session state, and foundational mapping or gateway roles.
Ports and Adapters
Ports and Adapters addresses the problem of keeping domain and application semantics independent from specific infrastructure, protocols, user interfaces, and external systems.
Process Managers
Process managers are an orchestration pattern for coordinating a process across participants, time, effects, and failure boundaries.
Sagas
Sagas are process managers specialized for domain process recovery across system boundaries where one atomic transaction is unavailable, too expensive, or misaligned with the domain process.
Sagas and Process Managers
This note connects the dedicated entries for sagas and process managers.
Transactional Inbox
The transactional inbox addresses the consumer-side problem of processing a delivered input exactly once in domain meaning when the delivery substrate may redeliver it.
Transactional Outbox
Transactional outbox is the architecture practice of using an outbox to tie an accepted local state change to downstream publication responsibility without a distributed transaction between storage and consumer.
Weak Isolation Patterns
Weak isolation patterns are architecture practices for preserving useful correctness when one ACID transaction or two-phase commit boundary is unavailable, too expensive, or misaligned with the domain process. This is mostly about deciding which weaker guarantees become explicit parts of the domain protocol, entity model, process state, and recovery behavior.
Workflow Patterns
Workflow Patterns is a research-based pattern language for recurring requirements in process-aware information systems and workflow languages. The original catalog identifies twenty implementation-independent control-flow patterns. The broader initiative also catalogs data, resource assignment, exception handling, and event-log imperfections.