Part three of three on the shape of the enterprise technology organization.

Part one changed the shape of the organization. Part two changed the boundaries of the systems underneath it. Both left the same question open, and it is the one that decides whether any of this works: when something has to move from one domain to another, who owns it?

The instinct is to put someone in the middle. A coordinator, an integration team, a journey owner, a platform that everything routes through. Every enterprise has tried some version of this, and it is always where the slowness comes back.

The instinct of the moment runs the same way, dressed in new clothes. The prevailing advice for the AI era is to build a better middle — a central orchestration layer, a shared ontology, a clean core that everything still routes through. This argues the opposite: the AI era is precisely when the middle becomes removable. The answer to who owns the crossing is that there is nothing in the middle to own, because the crossing is not a place. It is a contract.


What IT Keeps

Start with what the technology organization is for, because in this model it is for much less than it used to be.

IT keeps three things: infrastructure, security, and a data platform. It owns them, funds them, and runs them. That is the entire remaining footprint of a central technology organization. Everything that used to sit under it — the application teams, the delivery groups, the product owners embedded in the business — moves into the domains, where the business owns them, funds them, and runs them.

This is not a smaller version of the old IT organization. It is a different object. The old one existed to stand between the business and its systems and translate. That gap is what vendors and AI have closed. What is left is not a translator. It is the keeper of three utilities that every domain consumes and none of them coordinate around.

The test for whether something belongs to IT is simple: does it sit inside a business workflow, or underneath all of them? Infrastructure is underneath. Security is underneath. The data platform is underneath. Anything that sits inside a workflow belongs to the domain that runs that workflow, and to no one else.


The Only Way to Cross

A domain owns its work, its systems, and its decisions. It does not reach into another domain, and nothing reaches into it. So when information or work has to cross a boundary, it crosses in exactly one way: through a contract the domain publishes.

A domain exposes what it is willing to share — an appointment, a balance, a result, an action it will take on request — and the domain that needs it consumes that contract directly. Peer to peer. No broker.

Publishing a contract used to be a project in itself — an integration layer, an interface team, a year of work. That cost has collapsed. Standing up an endpoint that exposes what a domain knows — an MCP server over its data and the actions it will take — is now a day’s work, not a program. When enabling the contract is that cheap, a domain can expose what it knows without any reason to merge systems instead. The contract stops being the hard part. It becomes the crossing.

Ownership falls out of this without anyone appointing it. The domain that publishes a contract owns that what it publishes is correct. The domain that consumes it owns what it does with it. When one domain needs another to act, the asking domain owns the request and the owning domain owns the act. There is no third party, because the contract is the only thing that crosses.

The key point:

The contract is the only thing that crosses, and a contract has two ends and no middle.


There Is No Middle to Own

Return to the question parts one and two left open: a patient is admitted, treated, and billed. The work crosses admissions, clinical, and revenue cycle. Who owns the journey?

In the old enterprise, the answer was a program, or a platform, or a person whose title contained the words “end to end.” Something sat in the middle and moved the work across. And it was always the bottleneck, because everything waited on it.

In this model no one owns the journey, because the journey is not a thing. It is a sequence of domains, each accountable for its own part, connected by contracts. What is owned is the outcome, and the outcome is owned by the domain where it lands. Revenue capture is owned by revenue cycle. So revenue cycle pulls what it needs — the admission, the eligibility, the clinical fact — through the contracts those domains publish, and raises a request when it needs one of them to act.

The shift is small to state and large in effect. Stop putting a function in the middle to push work across boundaries, and let the domain that is accountable for the result reach for what it needs. The middle disappears, and the queue goes with it.

The key point:

Replace the orchestrator with the consumer.


The Data Platform Is a Consumer, Not a Switchboard

This raises the obvious objection. The data platform is shared. Anything shared that sits in the path becomes the blocker. So is the data platform not the middle, wearing a different coat?

It is not — as long as it is never in the path. Domains do not talk to each other through the data platform. They talk to each other directly, through contracts. The data platform is simply another consumer of those same contracts. It reads from the domains to answer the questions no single domain owns: the enterprise view, the analytics, the reporting, the trends.

It converges information where the questions are asked, not where the work is done. It sits underneath every workflow and inside none of them. The moment a domain has to route through it to reach another domain, it has become the switchboard, and the model has failed. Keep it a reader and it stays a utility.


Support Is a Conversation, Not a System

Support looks like the exception, because a customer’s problem does not respect domain boundaries. A single call can touch scheduling, billing, and a device in the field. The temptation is to build one support function that reaches into every system to resolve it — which is to rebuild the middle with a headset on.

Support is a domain. It owns the conversation, not the systems behind it. It captures the contact, confirms identity, triages, routes, tracks, and owns the promise made to the customer. When resolution needs another domain to act, support raises a request through that domain’s contract. It does not log into the domain’s system and fix it.

Field service is a separate domain, not a part of support. It owns dispatch, scheduling, parts, and the technician’s work, and it receives requests the way any domain does. Support routes to it. Neither owns the space between them, because there is no space — only a contract.

The key point:

Support owns the conversation, never the system of record.


What Is Left Unowned

A model earns trust by naming what it does not solve, so here is the edge.

Two things genuinely resist this structure. The first is the end-to-end promise. Support owns the commitment made to the customer, but the clock runs inside domains support does not control. Accountability for the whole is real, and it does not sit cleanly in any one domain. The second is action across a boundary. Reading another domain’s contract is easy. Getting another domain to reliably act on a request — to write back, to change its own state on someone else’s behalf — is the hard, unglamorous integration problem that every version of this has run into.

These are not reasons the model fails. They are the two places where the work actually is, once the structure is right. Everything else the old enterprise spent its coordination budget on was self-inflicted — the cost of a middle that did not need to exist.


Final Thoughts

The old enterprise held itself together with a middle. A technology organization that stood between the business and its systems, a platform that everything crossed, a layer of coordination that grew every time the business did. The middle was where the translation happened, and it was where the waiting happened, and for thirty years there was no way to remove it.

There is now. Collapse the bridge, draw the lines, and delete the middle. What is left is an organization that owns nothing in common but the ground it stands on — three utilities underneath, business-owned domains above, and contracts where they meet. Nothing in between, because nothing in between was ever the point.

Series — overview: The Agentic Enterprise Needs a Spine, Not a Mesh · Part one: The Enterprise Without a Bridge · Part two: Where the Lines Should Be Drawn · Part three: The Contract Is the Crossing

Posted in ,