Architecture Knowledge Base
This site collects architectural concepts, specifications, examples, and reference material for building software around autonomous domain capabilities.
The ideas documented here grew out of many years of working with Domain-Driven Design, object-oriented modeling, layered architectures, vertical slices, event sourcing, and distributed systems. Many of those ideas had useful intentions, but in practice they often pushed software toward shared models, technical layers, repositories, services, and large coordination structures.
The direction here is different.
The central idea is that the domain is not primarily represented by a shared object model. The domain is built from autonomous capabilities. Each capability owns its own processing boundary, interprets the facts or state relevant to its decision, and returns a clear result.
This knowledge base documents the vocabulary and structure around that idea.
Core Concepts
- Request Processing Units describe internal domain capabilities.
- Reactors describe coordination when one interaction needs several capabilities or external operations.
- Providers describe access to external resources or capabilities.
- Delivery Mechanisms describe translation between external requests and internal processing.
- User Interactions describe outside-facing processes from trigger to response.
Specifications
Some ideas need a stricter contract.
- Command Context Consistency defines how an event store supports command decisions based on the facts relevant to a command context.
Intention
The intention is not to create another generic architecture style.
The intention is to make ownership boundaries explicit:
- user interactions are not domain capabilities
- delivery mechanisms are not domain logic
- reactors coordinate but do not decide
- providers access external resources but do not own domain behavior
- RPUs own domain capabilities
- consistency belongs to the facts relevant to a command decision
This structure keeps domain behavior local, reduces coupling, and makes systems easier to change without constantly reshaping shared models or technical layers.