Skip to content
← All articles
5 min readCloud governance

Cloud governance engineers can actually use

Governance is not a policy library. It is the experience an engineer has when a control helps, blocks, or surprises them.

Policy is an interface

A policy is one of the few platform features every engineer eventually meets. The meeting is usually a failed deployment. What the engineer sees is a name, a scope, and maybe a link. What they need is the rule that was violated, why it exists, what to do instead, and who can grant an exception. When those are missing, the control is technically enforced and organizationally bypassed.

Treat policy names, denial context, and the exception path as product surface. They are read under pressure by someone trying to ship.

Start with what gets blocked

A governance review that begins with a framework produces a long list of controls. A review that begins with blocked requests produces a shorter list of real friction. Collect the exceptions people are already making, the deployments that fail repeatedly, and the controls nobody can explain. That evidence shows which guardrails are doing work and which are inherited noise.

This is not an argument for fewer controls. It is an argument for placing them where they change behavior. A control that is audited but never read is not governance. It is a log.

Quantify the friction lightly. Count how often a control appears in support requests, how long an exception takes, and how many deployments are retried after a denial. These are operational measures, not performance claims, and they show whether a change helped. If the platform team cannot produce those numbers, start a simple log. The act of recording is usually enough to reveal the pattern.

Deny, audit, and the missing third option

Most policy discussions collapse into deny versus audit. Deny prevents unsafe work. Audit records it and lets it continue. The missing option is the supported path: a template, a module, or a documented pattern that lets the engineer do the legitimate thing without an exception.

For each important deny, write down the supported alternative and test it. If the alternative does not exist, the deny is a prohibition, not a guardrail. In Azure Policy terms, that may mean a DeployIfNotExists or Modify policy for the standard case, an initiative for the baseline, and an exemption process for the rest. The mechanism matters less than the existence of a viable path.

Policy as code only helps when it is tested like code. Evaluate definitions against representative resources in a sandbox subscription, inspect the what-if output, and review the diff when an initiative changes. A policy that has never been evaluated against a real resource is a hypothesis, and the first engineer to meet it becomes the test.

Exceptions need an owner and an expiry

An exception without an owner is a permanent undocumented control change. An exception without an expiry is a slow rewrite of the policy. Both are common because the request is urgent and the follow-up is not.

Make the exception record part of the platform: requester, reason, scope, risk accepted, approver, expiry, and the condition for removal. Review open exceptions on a schedule and report them alongside policy compliance. The goal is not zero exceptions. It is a set of exceptions someone can defend.

Identity and network controls are part of the experience

Governance is often discussed as policy, but identity and network controls shape daily work more directly. A role model that requires standing production access, a private DNS zone nobody owns, or a network path only one team understands will generate workarounds regardless of how well the policies are written.

Review role assignments and privileged access with the same lens as policy: who can change what, how the change is approved, and how it is reviewed. For network controls, make the supported path the easy path: a standard workload network module, clear private endpoint guidance, and named owners for shared DNS. Engineers follow guardrails that lead somewhere.

Make the control set legible

A governance model becomes usable when an engineer can answer three questions. Which controls apply to me? Why? What happens if I need an exception? That usually means fewer initiatives, clearer names, and a single entry point for the answer. It also means versioning policy as code and reviewing changes like any other production change.

Avoid publishing a control catalog nobody maintains. A short, current page with owners and review dates is more useful than a comprehensive matrix that is six months stale. If the organization needs the matrix for audit, generate it from the policy definitions rather than maintaining it by hand.

Rollout is part of legibility. A new deny should be announced with its scope, its supported alternative, and its effective date. Run it in audit for a defined period, review the findings with the teams it affects, and only then enforce. The same discipline applies to changing an existing control. Treat it as a breaking change to an interface, because that is what it is.

A practical review sequence

Start with a representative workload and walk it from subscription request to production. Record every control it meets, every manual approval, and every workaround. Then ask which controls protect a real risk, which are duplicated, and which lack a supported path. Fix the highest-friction control first, with its name, owner, alternative, and exception path.

Governance improves through a series of small, visible changes. The measure is not how many policies exist. It is whether engineers can move safely without going around the platform.

Related service

Cloud governance

Next step

If this is the decision in front of you, describe the constraint. I will tell you whether the work fits.

Start a project inquiry