Less reconciliation of meaning.
Teams can ask the same named question of the same model. A different screen does not need to invent a different definition of readiness, eligibility or completeness.
DOMAIN OBJECTS / A SHARED MODEL OF THE BUSINESS
Fields describe. Relationships connect. Lifecycles guide. Rules protect. Commands request. Events remember.
Together, they give business meaning a durable home.
A person, an asset, an agreement, a case, a job.
The things differ. The building blocks are shared.See what each layer makes possible ↓
A domain object models one meaningful business thing: its facts, connections, permitted behavior and accepted history. With durable persistence, that history continues beyond the life of any screen or running application.
01 / Identity
A name can change. A team can change. An application can be replaced. Stable identity lets the business keep talking about the same thing through all of it.
Recognise one thing across its changes.
Every fact, connection and accepted change has a stable subject. The object’s story stays attached to the object.
Without identity, correct information can still be attached to the wrong thing.
02 / Fields & evidence
Fields describe what is known about the object. In DO, a fact is a known value with supporting evidence—or an explicit unknown with a reason. Its source matters as much as its value.
Capture information in a consistent shape.
Identity tells us what the information is about. Evidence tells us why it can be used, or why a conclusion must wait.
Missing is not zero. Conflicting sources do not become certainty simply because a field has room for only one value.
03 / Relationships
Business meaning rarely fits inside one record. Objects belong to, depend on, authorise, contain or fulfil other objects. A named relationship makes that connection explicit and can carry facts about the connection itself.
Describe how two things are connected.
Conclusions can depend on related evidence, not just local fields. The business becomes a graph of meaningful connections.
A relationship is more than a link on a screen. Its meaning, identity and permitted cardinality matter.
04 / Derived outcomes
“Complete”, “eligible” and “ready” are conclusions. Define each once from the relevant facts and relationships, then let applications ask for it by name. The answer can be true, false or unknown.
Calculate a useful answer.
The same meaning can inform a screen, a semantic query and a command rule. Follow its dependencies back to the evidence to understand why.
An outcome is computed, not another editable flag. It must not become a competing source of truth.
05 / Lifecycle
A status tells you where something is. A lifecycle defines which moves are legal from there. The business authors the possible states and transitions; an arbitrary status edit does not create a valid transition.
Describe the legitimate progression of a thing.
Facts and outcomes tell us its condition. Lifecycle tells us which futures are permitted from its current position.
Not every fact change is a lifecycle transition. Both still need a governed path to change.
06 / Constraints & invariants
A constraint asks whether a particular change may happen. An invariant asks whether the resulting state is valid. Both must be established as true before their governed change can commit.
Express a business requirement.
Rules use facts, related context and outcomes to protect every applicable change path—not just the most obvious button.
A check at one doorway cannot protect every later edit. Invariants guard candidate state even when the lifecycle does not move.
07 / Commands & authority
A command expresses intent: create, amend, assign, activate, close. It carries validated inputs and can be refused. The runtime evaluates the request against the model and the supplied actor’s authority.
Name what someone wants to do.
Lifecycle, conditions and authority determine what this actor may attempt. The same decision boundary serves a person, an integration or automation.
A displayed action is a preview. Execution rechecks current state; a stale screen cannot grant permission.
08 / Events & provenance
An accepted command proposes events. Once committed, those events record what changed. Current state is built from that accepted history; later corrections add new history rather than silently rewriting what happened.
Keep a record of a change.
Facts gain a causal history. Conclusions explain why they hold; events explain how the object reached its current state.
A request is not an event. A proposed event is not durable until persistence succeeds.
09 / Durability & consistency
With a durable persistence host, accepted events and command receipts survive restarts and lost responses. Version checks prevent a decision based on stale observations from becoming a committed change.
Retain information after the session ends.
The object keeps its identity, accepted state and history. Repeating the same complete intent and command identity recovers its receipt instead of repeating the business change.
The in-memory host is temporary. Durable storage, backups and recovery must be chosen and operated; the object need not run continuously.
10 / Effects & recovery
A durable event can cause an external action: notify, schedule or update another system. Delivery happens after the business change is recorded and has its own retry and reconciliation path.
Connect one system to another.
Business truth and delivery status stay distinct. A failed notification does not erase an accepted change. New information returns through a new command.
An effect is a boundary capability, not a ninth core primitive. External delivery still needs workers and idempotent destinations.
11 / The connected business
One object’s accepted change can alter the evidence relevant to another. Outcomes are reevaluated; different commands become available. A business process can be understood as permitted changes across a graph of durable objects.
Each object describes one meaningful thing.
People, applications and automation coordinate around a common model of what is known, what follows, what may happen and what did happen.
The model defines the meaning. It does not make every related change one global transaction or automatically operate every workflow.
EXPERIENCE THE COMBINATION
An agnostic teaching model, not a live DO runtime. Its illustrative lifecycle is Ready → Active. Its authored activation rule requires known evidence, a satisfied related condition and allowed authority.
Controls configure fictional observations. They are locked after activation; reset to explore another case.
The model can offer an action. Only a validated, committed change creates an event.
WHY THE COMBINATION MATTERS
The model connects what is known, what follows, what may happen and what did happen. Each capability supports the others.
A conceptual comparison of responsibilities, not a supported mode for disabling runtime safeguards.
THE BUSINESS BENEFIT
The value is larger than one approved request. People and applications can work from consistent meanings, enforce the same conditions and trace conclusions to evidence—across many kinds of business process.
Teams can ask the same named question of the same model. A different screen does not need to invent a different definition of readiness, eligibility or completeness.
Relationships expose dependencies. Lifecycles and rules expose legal next steps. People and automation can discover permitted work rather than reproduce every decision tree.
Changes through the governed boundary face the same lifecycle, authority and candidate-state checks. A new integration does not get a separate definition of a valid business change.
Outcomes trace to evidence. Events trace how state changed. Missing knowledge stays visible, helping distinguish a business correction from a need for better information.
Durable identity and accepted history preserve continuity through handovers and restarts. Safe retries recover results without asking the business to perform the same change twice.
One compiled contract can serve different applications and supported persistence hosts. Interfaces can evolve around that meaning; model changes still require deliberate releases and migrations.
Evidenced facts, including explicit unknowns.
Reproducible conclusions under the model and context.
Accepted changes recorded as durable events.
Dependable truth is evidenced, explainable and governed. It is not a guarantee that every source or authored policy matches reality. Incorrect evidence can still lead to an incorrect conclusion; the model preserves the basis needed to investigate and correct it.
ONE MODEL. MANY KINDS OF BUSINESS.
Every domain supplies its own facts, connections, policies and legitimate changes. DO supplies the structure that lets those choices work together.
Know what it is.
Understand what follows.
Govern what happens next.
Remember why.
The compiler validates authored declarations and produces a canonical model, application API, compatibility information, stable symbols and TypeScript builders. The governed WebAssembly engine evaluates meaning. Persistence adapters own transactions, versions, receipts, projections and outbox storage.
Applications use execute, read, query and affordances. Supported hosts include memory, browser IndexedDB, PostgreSQL and Cloudflare Durable Object SQLite. Domain Objects are business concepts; Cloudflare Durable Objects are one hosting option.
The business must agree its definitions and evidence standards. Applications still need authentication, tenant isolation, read and export access controls, migrations, backups, effect workers and operational verification. Historical analytics require retained evidence or verified snapshots; current state alone is not a historical report.
Processes with shared rules, meaningful relationships and controlled changes benefit most. A small application with little shared behavior may not justify the extra modelling discipline. The model is not a claim that every business process can be automated without judgement.