Governing a Platform Where Anyone Can Build

For thirty years, building meant asking IT and waiting in a queue. That constraint is gone, and it took the org's main safety mechanism with it — because the queue was never just a bottleneck. It was also the place governance happened.

On a Friday afternoon, a senior analyst in a claims operation who has never written a line of production code builds something that works. She has spent two years knowing exactly which exceptions clog intake, which documents get misfiled, which vendor emails need a particular kind of chasing, and now, for the first time, she can turn that knowledge directly into a working autonomous workflow without filing a ticket and waiting a quarter for someone to interpret her request badly. By Monday the thing is running, quietly clearing a backlog that had been someone's full-time misery, and three of her colleagues have asked her to build them one too. Nobody in IT knows it exists. It touches customer records, it calls an external system with a credential she pasted in herself, and it is, by every reasonable measure, a small triumph of the kind organizations say they want more of.

It is also the precise shape of the problem that is about to define the next decade of enterprise technology. The barrier between having an idea and shipping an automation has genuinely collapsed, and the people best positioned to build — the domain experts who understand the work — can now do so without passing through any of the checkpoints a traditional software delivery process quietly enforced. That collapse is a real gain in capability and a real loss of control at the same instant, and most organizations have noticed only the first half. They are celebrating the citizen builder while the governance that used to be a byproduct of scarcity evaporates underneath them.

The build got democratized before the governance did

For as long as anyone reading this has been working, the ability to build software was rationed, and the rationing did more than one job. The obvious job was throughput: there were only so many engineers, so work queued, and the queue decided what got built. But the queue was also, almost accidentally, where a dozen other things happened. It was where a security review got attached, where someone checked whether the data being touched was allowed to be touched, where the new thing got a name and an owner, where a second person looked at the logic before it went anywhere near a customer. None of that was the point of the queue. All of it depended on the queue existing. When building was scarce and centralized, governance came free, bundled invisibly into the fact that everything passed through the same small set of hands.

Now the scarcity is gone and the bundle has come apart. When a domain expert can assemble Specialist Agents, wire in a data source, and put an autonomous worker into production over a weekend, every one of those bundled checks becomes a separate thing that has to be deliberately provided — or it simply does not happen. This is the mechanism behind what everyone now calls shadow AI, and it is worth being precise about what shadow AI actually is, because the phrase makes it sound like defiance. It is almost never defiance. It is water finding the downhill path. When the sanctioned way to build is slower or more bureaucratic than the ungoverned way, capable people will build the ungoverned way, not because they are reckless but because they have a job to do and a tool in front of them that lets them do it today. Shadow AI is not a people problem. It is a gradient problem, and the gradient points away from wherever governance made itself the harder path.

The stakes of getting this wrong are not abstract, and the market is already pricing them in. Gartner has predicted that over forty percent of agentic AI projects will be canceled by the end of 2027, naming inadequate risk controls alongside escalating costs and unclear value among the reasons. Read that in the context of a hundred analysts each building their own claims workflow in their own corner, and the failure mode writes itself. It is not that any single citizen-built automation is dangerous. It is that a sprawl of them, each with its own pasted credentials, its own undocumented logic, its own silent assumptions about what data it may see, adds up to a risk surface no one is looking at — until the day one of them does something expensive and there is no one who can even say who built it or why.

Governance is not a gate you stand at; it is a path you make easiest

The instinct, when leadership finally notices the sprawl, is to slam the gate — to lock building back down, route everything through a central team again, and reinstate the queue by fiat. This fails in a predictable way: it does not stop the building, it only makes the building invisible. You cannot un-democratize a capability people have already tasted, and any policy that tries will simply push the most capable and most motivated builders further into the shadows, where they are now not only ungoverned but actively evading governance. The gate does not close the gradient. It steepens it.

The organizations getting this right have understood something counterintuitive: in a world where anyone can build, governance stops being a checkpoint you stand at and becomes a path you engineer to be the easiest one available. The whole discipline inverts. Instead of asking how to stop people from building outside the sanctioned system, you ask how to make the sanctioned system so obviously the better place to build that no one wants to leave it. This is why the platform itself becomes the primary instrument of governance, not a set of policies wrapped around a free-for-all. When the same environment that lets the claims analyst build her workflow in an afternoon is also the environment that gives her a managed credential she never has to see, a data source already scoped to what she is permitted to touch, an LLM Gateway that meters and logs every model call without her configuring anything, and a Model Context Protocol connection to the vendor system that IT sanctioned once for everyone — then choosing the governed path is not a compliance sacrifice. It is the path with less friction, and people take the path with less friction every time.

Three things in particular have to move from optional to structural, and each maps to a piece of the old bundled queue. The first is a sanctioned surface for building at all — a single Enterprise AI Platform where the building happens, so that the act of creating an autonomous worker is also, automatically, the act of registering it, giving it an owner, and placing it somewhere it can be seen. The second is review that lives in the build path rather than beside it, so that a workflow touching money, customer data, or an outbound action carries Human-in-the-Loop gates as a native property of how it was assembled, not as a separate approval process someone remembers to invoke. The third, and the one most often forgotten, is versioning — because a citizen-built automation is not a static artifact but a living thing its author will change again next week, and without a version history there is no way to answer the two questions that every governance conversation eventually comes down to: what is this doing right now, and what changed between when it worked and when it didn't. A platform that treats every workflow as a versioned, owned, observable object turns the terrifying question "what is running out there?" into something you can actually query, and that shift from unknowable to auditable is most of what governance was ever trying to buy.

What IT actually becomes when everyone can build

None of this diminishes the role of the people who used to hold the monopoly on building; it relocates it. When the domain experts across an organization can turn their knowledge directly into Autonomous AI Workers, the scarce and valuable discipline is no longer the building — that has been distributed to the people who understand the work best, which is where it belonged all along. The scarce discipline becomes the design and maintenance of the environment they build in. Someone has to decide which external systems get a sanctioned MCP connection and which do not, which data sources are scoped to which teams, where the Human-in-the-Loop gates are mandatory versus advisory, what the review path looks like for a workflow that touches a customer versus one that only reformats an internal report. That is not a lesser job than building. It is a harder and more leveraged one, because a single good decision about the platform governs a thousand workflows its stewards will never personally see.

This is the quiet promotion that the shift toward an autonomous enterprise hands to IT, and the organizations that resent it will lose to the ones that embrace it. The old role was to be the bottleneck — the team that built the things, and by building them, controlled them. The new role is to be the ground the building happens on: to make the sanctioned platform the fastest place to build, so that governance is something the domain experts pass through effortlessly rather than something they route around, and to spend the attention freed up by no longer building everything on the far more valuable work of deciding what the platform should permit. The measure of the function stops being how much it ships and starts being how little gets built outside the walls it maintains.

So the useful way to think about governance where anyone can build is not as a wall around the builders, and not as a queue they wait in, but as terrain. Water runs downhill regardless of where you wish it would go, and the only durable way to direct it is to shape the ground so that the path you want is also the path of least resistance. The organizations that keep trying to dam the flow will watch it seep around them into the shadows, one pasted credential at a time. The ones that shape the terrain — that make the governed way the easy way — will find they have not traded capability for control at all. They will have discovered that the two were never in tension: the platform that makes building safe is the same one that makes building fast, and the job of IT was always to build that ground and then get out of the way.