Where the Developer Ends and the Infrastructure Begins

Written By

Maximiliano Aguirre

Published

November 19, 2026

Illustration of a small person holding a tablet in front of a pink tower with an open door, next to a wall of pipes and gears, under a blue sky

When a development team asks for "more autonomy to deploy," it almost always hides a tension nobody names out loud: autonomy for whom, and at the cost of what control. Giving direct access to infrastructure solves speed and breaks governance. Keeping control centralized protects governance and turns the infrastructure team into a bottleneck. Most internal platforms fail because they try to resolve this tension with more tools, when the problem isn't tooling at all: it's poorly defined boundaries between two teams.

We recently worked with a wealth management firm that had exactly this problem. They wanted their developers to deploy applications on Azure quickly and without friction, but without giving them access to Terraform or to cloud resources—especially junior and mid-level profiles, who didn't have and shouldn't need that context. At the same time, they couldn't afford for every deployment to depend on someone from the infrastructure team being available to run it by hand.

The question that defined the whole project wasn't "which IaC tool do we use?" It was: where, exactly, do you draw the line between what a developer can request and what the platform controls?

A catalog as a contract

The answer ended up being, literally, a written contract. In this case, one YAML file per application, where the developer declares what they need—the app's name, which environments it should run in—and opens a pull request. They never write Terraform. They never enter the Azure portal. On the other side, that file is interpreted according to rules the platform team defines and fully controls: what each field means, which resources get created, with what configuration.

That catalog isn't a convenience layer. It's the boundary. It gives the developer a narrow, safe vocabulary to ask for what they need, and leaves the platform in full control of what that vocabulary means in the real infrastructure. And because everything goes through a pull request, every change is reviewed, versioned and auditable—something manual coordination could never guarantee.

Discomfort as a decision, not an accident

The same principle showed up in another, even more uncomfortable decision: deliberately separating CI from CD. One tool builds and validates the code. Another orchestrates the deployment. The only connection between them is a webhook—nothing more.

It's a constraint that can feel artificial day to day. You could fold everything into a single tool and save a layer of indirection. But that discomfort is exactly what lets you replace the CD tool tomorrow without touching CI, or vice versa. It's the same pattern as the catalog: pay a little friction today so that no future change forces you to redo everything else.

The problem is rarely technical

What makes projects like this hard isn't standing up infrastructure as code—with today's tools, that's relatively mechanical. The hard part is designing the right boundary between the teams who will live with that infrastructure every day. When that boundary is poorly defined, no amount of automation makes up for it: it only hides the problem a little deeper in the system.

If your development team depends on another team to move forward, or your platform team has become a bottleneck trying to hold on to control, you probably don't need a new tool. You need a clear contract between the two.