DevOps were supposed to solve a problem.
The promise was simple, shared responsibility,
developers and operations working together.
No more silos, no more throwing code over the wall
and waiting for ops to approve it, speed, autonomy,
faster delivery.
But in reality, it just moved the bottleneck.
It didn't eliminate it.
For years, operations teams were the constraint.
Developers would request an environment,
then ops would review it, schedule it, and provision it.
This process took weeks or sometimes months
because the bottleneck was clear.
It was ops.
So we fixed that.
We gave developers the tools, infrastructure as code,
container orchestration, cloud platforms,
the ability to provision their own resources.
And what happened?
Developers started waiting for infrastructure
the same way ops waited for approvals
because now developers own more than just code.
They own networking, security, compliance, policy, monitoring,
and troubleshooting.
The cognitive load exploded.
And the ticket queues didn't disappear.
They just changed hands.
The structural floor isn't people.
It's the operating model.
Platform engineering fixes this by treating infrastructure
not as a service you request, but as a product
you consume.
This episode explores how that shift changes everything.
How golden parts eliminate choice, how governance becomes
automatic, how the bottleneck gets eliminated
instead of just relocated.
Subscribe to the M365FM podcast for deep dives
into the systems that drive enterprise velocity.
Why DevOps failed at scale?
DevOps worked.
For small teams, it was remarkable.
A few developers and a few operators
shared ownership and direct communication.
These fast feedback loops accelerated delivery,
and at that scale, the model actually
did eliminate the bottleneck.
But then organizations scaled.
50 developers, 100, 500, and the model broke.
DevOps promised shared responsibility,
but what it actually delivered was distributed complexity.
Developers inherited the entire operational stack,
not just code, infrastructure, security policy, identity
and access management, monitoring, incident response.
All of it sitting in the developers' mental model
alongside the application logic they were supposed
to be building.
The cognitive load explosion happened quietly.
Research shows developers spend 40% to 50% of their time
on undifferentiated, heavy lifting, not on product features,
not on solving business problems, on infrastructure toil,
on figuring out which security group to attach,
on debugging networking issues that have nothing to do
with their code.
On waiting for approvals that should have been automated,
the tickets didn't disappear.
They just changed form.
Instead of asking to provision an environment,
the question became, why a deployment wasn't working?
Developers had to become operators just to find the answer.
They were context switching between code review,
infrastructure debugging, compliance documentation,
and incident response.
Each switch costs focus and drains cognitive capacity,
so by the time they get back to the actual build,
the context is gone.
Dora metrics improved.
Deployment frequency went up, lead time went down,
on paper everything looked faster.
But developer satisfaction dropped,
because being faster doesn't matter if you're burned out.
It doesn't matter if you are spending your time
on repetitive setup tasks instead of building things
that matter.
This is the trap DevOps created at scale.
The model works for a startup, a team of 10 people
all wearing multiple hats.
Everyone understands the full stack.
Communication is direct, feedback is immediate.
It breaks for an enterprise, because an enterprise
isn't a startup with more people.
It's a different structural problem.
You have dozens of teams and competing priorities.
You have different compliance requirements
for different applications.
Shared infrastructure serves multiple workloads
and different levels of risk tolerance
mean policy needs to be enforced consistently.
Try solving all that by sharing responsibility,
try managing hundreds of database access requests manually,
try ensuring every developer in the organization
knows the current network topology.
Try keeping security policies consistent
across a hundred different infrastructure decisions
made by a hundred different teams who
have slightly different interpretations
of what least privilege means.
You can't, the model breaks.
And that's where enterprises still are.
They've adopted DevOps.
They've built CI/CD pipelines.
They've given developers cloud access.
But the cognitive load keeps growing.
The approval processes keep multiplying.
The ticket queues just moved.
They didn't disappear.
The operational model didn't change.
Only the form of the bottleneck, platform engineering
doesn't try to fix DevOps.
It replaces the operating model entirely.
The cognitive load crisis.
Cognitive load is easy to define.
It is the mental effort you need to understand
and run a system, not physical effort, mental effort.
It is the number of different concepts
you have to juggle in your head at once.
It is the constant context switching.
It is the depth of knowledge you need
just to make a simple decision without breaking the whole
environment.
In the old world of infrastructure,
this load was localized.
Operators understood the hardware,
developers understood the apps.
The domains were separate.
A developer did not need to know how to fix a network
misconfiguration because they just wrote the code
and let ops handle the rest.
That boundary dissolved.
Modern cloud infrastructure now demands
that you know five different worlds.
Networking, security, policy, identity, monitoring.
A developer on a modern platform
has to understand virtual networks and security groups.
They have to know Azure policy and which resources
are allowed in which regions.
They have to manage identities and role-based access.
They have to figure out logging strategies
just to see why something failed in production.
And all of that sits on top of the actual code
they are supposed to be writing.
The problem is not that one domain is too hard.
It is that they compound.
You do not get to choose between networking or security.
You need both.
You need them to talk to each other.
If you mess up an identity, the app
deploys but cannot talk to the database.
If you click the wrong security group rule,
the app runs but cannot find its dependencies.
If you trip a policy violation,
the whole deployment fails at the last second
after you have put in hours of work.
So developers' context switch, constantly.
They are writing code, something breaks.
Is it the code?
Is it the infrastructure?
Is it a policy issue?
Is it a permission problem?
They jump into the Azure portal to check the topology.
They verify role assignments.
They dig through policy audit logs, nothing.
So they jump back to the code.
Maybe it is an environment variable.
They search templates.
They check bicep files.
They verify parameters.
Finally, they find it.
Now they need to redeploy but the policy will not allow it.
They request an exception.
They wait for approval.
The approval comes back with three new conditions.
They redesign the approach.
They redeploy.
This time it works.
But an eight hour day just became 30 minutes of coding
and seven and a half hours of switching tabs.
That is not an exaggeration.
That is the daily reality for developers and organizations
that have not fixed this.
The cost is compounding.
Every time you switch tasks, there is a real price to pay.
Research shows it takes 15 to 25 minutes
to get back into deep focus after an interruption.
If a developer switches context six times a day,
they have lost three hours just trying to remember what they were doing.
They never get back to deep work.
They just stay in a fragmented mode.
Then the error start.
When you are fragmented, you miss the details.
You deploy without testing everything.
You overlook a small configuration.
You assume it is working when it is not.
You start introducing bugs that would not exist
if you just had an hour of quiet focus.
And then burnout.
Not because the work is too hard
but because the work is impossible to do well.
You cannot build high quality software
when 70% of your time is spent on infrastructure toil.
You cannot feel productive when eight hours of effort
only moves the needle 30 minutes.
You cannot stay engaged when every single task requires
jumping between five different systems,
each with its own logic and its own way of failing.
This is the cognitive load crisis.
It is not a tooling problem.
Better monitoring will not fix this.
Better logging will not fix it.
Faster deployments will not fix it.
Those tools only treat the symptoms.
The cause is the operating model.
Asking developers to own the full infrastructure stack
means asking them to master domains
that are not their specialty.
It means spreading complexity out instead of containing it.
It means building a system that looks great on a slide deck
but breaks in the real world.
Platform engineering fixes this.
By moving complexity to the right place.
What platform engineering actually is?
Platform engineering starts with a different assumption.
It does not ask developers to master infrastructure.
It does not ask them to own every domain
from networking to monitoring.
Instead, it treats infrastructure as something to be consumed,
not something to be learned.
This is a fundamental shift in how you operate.
DevOps is a culture.
It is a set of practices.
It is about shared responsibility.
You can do DevOps and keep the same messy structure
and the same manual systems.
You are just asking people to talk more
and automate a few scripts.
Platform engineering is a discipline.
It is the act of building an internal platform.
A product where the developers are the customers.
This requires a dedicated team.
Their only job is to take complexity away from the product teams.
Not by hiding it, but by building secure,
opinionated pathways that developers follow naturally.
Because the path is easier than doing it the old way.
The relationship changes.
In a DevOps model, the infrastructure team reacts.
Deploy this database.
Fix this network.
Review this policy.
The request might be a pull request instead of a ticket,
but the dynamic is the same.
Someone asks.
Someone else approves and delivers.
In a platform engineering model,
the team anticipates the request and eliminates it.
Instead of waiting for a developer to ask for a new environment,
the platform team builds an environment factory.
You click a button.
You get an environment.
The governance is already there.
The security is baked in.
The monitoring is already running.
The developer does not need to ask for permission
because the system was designed so that the right way is the only way.
Platform teams stop processing tickets and start studying pain.
They talk to developers.
They watch how they work.
They find the patterns that get built over and over again.
And they turn those patterns into products, self-service products.
Tools that developers choose to use because they are faster and safer
than doing it by hand.
This is where golden paths come in.
A golden path is the simplest, most supported way to get a task done.
It is not the only way.
You still have escape hatches for the weird edge cases.
But for 80% of the work, there is a clear root
with all the controls built in.
Security, compliance, observability.
It is all automatic because the path was designed that way from the start.
Developers follow the path because it is easier.
Using the path means you have an environment in minutes.
Trying to do it manually means weeks of waiting for security audits
and manual approvals.
The choice becomes obvious.
This requires a product mindset.
Platform teams have roadmaps.
They do user research.
They track how many people are actually using the features.
When developers ignore a new tool, the platform team does not blame the developers.
They ask why the tool failed.
They ask why the manual way was easier.
Success looks different now.
Traditional teams measure how many tickets they closed.
That matters, but it does not tell you if you are actually helping.
Platform teams measure adoption.
What percentage of the company is using the platform?
Are they satisfied?
Is it actually making delivery faster?
The platform that nobody uses is a failure.
A platform that everyone is forced to use, but hates is also a failure.
Success means developers choose the platform because it solves their problems better than anything else.
The shift from gatekeeper to enabler changes everything.
It changes what you measure.
It changes how you spend your day.
It changes how you know you are winning.
It removes the bottleneck because the bottleneck was not the people.
It was the model and the model just changed.
The golden path concept.
We need to be concrete about what a golden path actually is.
Because this concept shifts the entire conversation around how infrastructure should work, a golden
path is the opinionated, secure and well maintained route through your infrastructure.
It isn't a guideline, it isn't a recommendation.
It's the path designed, tested and optimized for your most common scenarios.
When a developer needs to deploy a microservice, they don't evaluate five different architectures
and pick the best one.
They follow the golden path for microservices.
That path already encodes every decision.
Network topology.
Storage configuration.
Identity setup.
Working and monitoring.
Security baselines.
Backup strategy.
Everything is predetermined.
The beauty of the golden path is that it encodes organizational standards without requiring
developers to memorize them.
Security teams don't need to audit every single deployment.
Compliance requirements don't need manual reviews.
Governance policies don't need to be understood by every engineer.
The path was designed by people who understand security and compliance.
And then it was embedded into the path itself.
When you follow the golden path, you're automatically compliant.
You're automatically secure.
You're automatically meeting organizational policy.
Not because you know the policy, but because the path makes it impossible to violate it.
This is the fundamental inversion.
Traditional infrastructure asks developers to learn policy and then follow it.
The responsibility for compliance lives with the developer.
They need to understand which security groups to attach, which roles to assign, which logging
settings are required.
They're responsible for getting it right.
And when something fails in audit, they are the ones who fail to follow the rules.
Golden paths flip this responsibility.
The path is designed, so compliance is automatic.
The developer doesn't need to know why certain decisions were made.
They don't need to understand as your policy syntax or memorize which identity patterns
are allowed.
They follow the path.
And compliance just happens.
The developer's only responsibility is to understand.
Does this path fit my use case?
That's a dramatically different cognitive burden.
For the 80% of workloads that fit predictable patterns, the answer is yes.
They follow the path, 15 minutes of setup, and they're done.
The environment is built.
The security baseline is applied.
The monitoring is configured.
You can start writing code.
For the 20% that don't fit the pattern, escape hatches exist.
A developer can request an exception and explain why they need a different approach.
But that request goes through an actual review.
Not because every request is reviewed, but because requests are rare.
When a request comes in, it gets attention.
This mechanism has a profound psychological effect.
Following the golden path isn't a constraint.
It's a relief.
You don't have to make decisions.
You don't have to understand networking to configure networking.
You don't have to be a security expert to deploy securely.
The path was designed by experts and you're following their decisions.
That's actually faster and safer than trying to design it yourself while learning the domain.
The impact on onboarding is measurable.
A new developer joins your organization.
In the old model, they spend weeks understanding infrastructure.
They read documentation.
They ask questions.
They build test environments.
They learn from mistakes.
They gradually build mental models of how things work.
It takes three months before they are independently productive.
With golden paths, they follow the path.
They deploy their first service to production in days.
They don't understand everything about the infrastructure yet, but they don't need to.
The path handles it.
They are productive immediately while learning the deeper context over time.
On-boarding time drops by 50% or more.
This efficiency compounds across the organization.
When every developer can self-serve their infrastructure without waiting for approval,
without needing to understand policy, without having to make dozens of configuration decisions.
Velocity changes.
Not just slightly, dramatically, because the constraint disappears.
Golden paths eliminate the constraint by removing choice where choice adds no value.
Developers make decisions about their application.
The infrastructure team made the decisions about infrastructure.
The two decisions are separate.
And both happen in parallel, instead of sequentially.
This is what platform engineering actually accomplishes.
It doesn't just accelerate delivery.
It restructures the operating model.
So the constraint, the bottleneck that plagued DevOps at scale, doesn't exist in the
first place.
The self-service shift.
The mechanical difference between the old operating model and the new one is where this
becomes tangible.
In the traditional infrastructure as a service model, the workflow is sequential.
A developer needs an environment, so they submit a ticket describing what they need.
Then they wait.
Someone from the operations team receives the ticket and reviews it.
They might ask clarifying questions, which leads to email back and forth.
Eventually they approve it or request changes.
Then they build the environment.
Configuration takes time.
They test it.
They hand it back to the developer.
Days have passed.
Sometimes weeks.
The developer has been waiting.
Context switching between other work.
Having email for updates, getting pulled back into focus when the environment finally arrives.
Then discovering it's not quite configured the way they needed.
Another ticket.
More waiting.
This is the bottleneck we talked about.
It's not malicious.
It's structural.
Operations teams are responsible for infrastructure stability and security.
So every request gets reviewed.
Every configuration gets verified.
The process exists to prevent mistakes that could crash production or expose data.
But the cost of that process is time.
Waiting time.
It's a process that will be eliminated across hundreds of developers that waiting time becomes a permanent break on velocity.
The platform model inverts this completely.
The developer doesn't submit a ticket.
They go to their internal developer platform.
They see a list of available templates.
They pick the one that matches what they need.
A microservice deployment environment.
A data platform.
A web application.
They click it.
A form appears with parameters.
What's the application name?
What's the resource group?
What's the environment, tier?
They fill out the form and review the summary.
It shows them exactly what will be created.
Then they click deploy.
Infrastructure provisions automatically, not in weeks, in minutes, while they're still sitting at their desk.
The security groups are configured the way the organization requires them.
The identity setup matches organizational standards.
The logging configuration is whatever the organization mandated.
The monitoring is already connected.
The backup policy is already in place.
All automatic.
The developer didn't need to understand any of this.
They didn't need to know networking or understand as your policy.
They didn't need to make decisions about what's secure and what isn't.
The infrastructure team made those decisions once when they built the template.
The template makes them for every deployment.
This requires one fundamental shift in how you think about governance.
Traditional governance is reactive.
A deployment happens.
A compliance audit reviews it.
And if something's wrong, you fix it after the fact.
Governance is something that happens to your infrastructure after it's already built.
It's a gate you pass through.
A checkpoint.
Automated governance is preventive.
Governance is built into the deployment itself.
The system won't allow a violation because the violation is architecturally impossible.
You can't misconfigure security because there's no way to configure it.
The security is applied automatically as part of the template.
You can't deploy to an unapproved region because the template only allows approved regions.
You can't forget to enable logging because logging is enabled by default.
Not optional.
This changes what self-service actually means.
Self-service in the old model meant less structured or less controlled.
Developers serving themselves with minimal oversight.
More risk.
Less governance.
That's a false dichotomy.
Information is developers serve themselves while governance is completely automated and
inescapable.
You get speed and compliance simultaneously.
The impact on context switching is immediate.
A developer used to spend significant time waiting for infrastructure.
They'd submit a ticket and shift focus to something else.
An hour later, the infrastructure will be ready and they'd shift focus back.
Another context switch.
Now?
They submit the request and the infrastructure is ready while they're still on the same
page.
No context switch.
Just continuous flow.
They click deploy.
They read the documentation while it's provisioning.
And they're ready to start using it before the coffee gets cold.
The measurable impact is dramatic.
Organizations implementing platform engineering with self-service infrastructure see time to
first deployment improve by three to five times.
Not three to five percent times.
A team that used to take two weeks from idea to deployed code in production now does
it in three days.
The difference isn't that developers got faster at their job.
It's that the bottleneck disappeared.
Developers focus on product work again.
They're not managing infrastructure requests.
They're not context switching between code and tickets.
They're not waiting.
They're building.
That's the work that matters.
They're not working on the work that creates business value.
And that's what they're finally getting time to do.
Internal developer platforms IDPs as the delivery mechanism.
Everything we've talked about, golden paths, self-service infrastructure, automated governance
needs a home.
It needs a place where developers go to find it, to discover it, to understand what's available,
to actually use it.
That's what an internal developer platform is.
An IDP isn't infrastructure.
It's the interface to infrastructure.
It's the user-facing portal where developers interact with everything the platform team
has built.
It's where developers come to find service catalogs.
They see a template for a web application.
They see one for an API.
They see one for a data pipeline.
Documentation is bundled with each one.
Examples show exactly how to use the template.
The parameters are clear.
It's organized.
It's discoverable.
You're not hunting through a Wiki or email lists trying to figure out what's available.
The IDP centralizes what used to be scattered across five different tools and three different
processes.
Before a developer needs an environment, they check a Wiki for documentation.
It's outdated.
The email someone asking what's current.
They wait for a response.
They check a GitHub repository for example configurations.
They find three different examples that do almost the same thing, but not quite.
They pick the closest one and modify it.
They submit a request to a different system.
They wait for approval.
They get the environment and it's not what they expected because the documentation didn't
match the actual setup.
With an IDP, they go to one place.
They select what they need.
They see the exact configuration that will be applied.
They see the security baseline that's included.
They can preview the costs.
Everything is transparent.
Then they deploy.
The portal reduces cognitive load in two ways.
First, it centralizes information.
You're not searching for documentation or guessing what's available because everything
is in one place, organized and searchable.
The cognitive cost of finding what you need drops to nearly zero.
Second, it makes choices obvious.
The platform team has already decided what the standard is and the IDP shows you that
standard.
You don't have to evaluate options or research best practices or debate with colleagues
about the right approach.
The approach is already chosen.
That reduces decision fatigue significantly.
But here's where adoption gets tricky.
The presence of an IDP doesn't guarantee use.
You can build a platform.
You can expose all the golden paths.
You can create beautiful documentation.
And developers still won't use it.
This is the adoption trap that kills most platform initiatives.
An organization launches an IDP.
They see 80% of their developers have access to it.
Adoption is 80%.
Management is happy.
We launched the platform successfully.
But then you measure actual usage.
How many developers actively use it each week?
30%.
How many services are deployed through it?
20%.
The rest are using workarounds, custom scripts and manual approaches.
80% adoption, 10% usage.
That's the trap.
The platform didn't fail because of the technology.
It failed because it didn't solve the problem developers actually cared about.
Maybe the templates don't match how teams actually work.
Maybe the interface is confusing.
Maybe the documentation assumes knowledge that new developers don't have.
A platform with low usage isn't a successful platform.
It's a tool.
Nobody wants to use.
And forcing adoption doesn't work.
You can mandate that teams use the platform.
But if it doesn't solve their problem better than alternatives, they'll find ways around
it.
This is why IDPs need to be treated as actual products.
A successful IDP has a product manager.
Someone whose job is to understand what developers need.
To track satisfaction.
To measure what templates are used in which are ignored.
To talk to teams about friction, the IDP isn't built once and then maintained.
It's designed.
It's tested with users.
It's refined based on feedback.
It's evolved as the organization's needs change, when an IDP is treated this way adoption
follows naturally.
Not because it's mandated, but because developers choose it, because it solves their problem
better than the alternative, because it makes their work easier.
That's the difference between a platform that exists and a platform that works.
How Azure Bicep enables golden paths?
Everything we've described automated governance, self-service infrastructure, golden paths that
encode organizational standards requires something concrete to make it work.
You can't build an IDP and a library of golden paths using documentation or manual processes.
You need infrastructure as code.
And specifically, you need something that makes it practical to create, maintain, and distribute
infrastructure templates at scale.
That's where Azure Bicep enters the picture.
Bicep is a domain-specific language built specifically for Azure infrastructure.
You write Bicep code.
It compiles down to ARM templates as your native deployment format.
But here's the critical difference.
Bicep is human readable.
ARM templates are JSON.
Hundreds of lines of nested objects, brackets, and syntax that's technically correct, but
cognitively dense.
Bicep strips that away.
You're writing something closer to how you actually think about infrastructure.
Define a virtual network.
Attach subnets.
Configure network security groups.
Link.
Identity.
Permissions.
And Bicep, those statements read like infrastructure thinking, not like JSON passing.
The readability matters more than you'd expect.
When infrastructure is defined in Bicep, reviewers can actually understand it.
Pull requests on Bicep code are legible.
A security engineer can read through a module and verify that it enforces the right policies.
A compliance officer can see that logging is configured correctly.
Another developer can look at an existing module and understand how it works well enough
to modify it or build on it.
This is impossibly hard with raw ARM templates.
The syntax gets in the way.
The real power of Bicep for platform engineering is modules.
A Bicep module is a reusable unit that encapsulates infrastructure logic.
You write a module once.
You use it hundreds of times.
That module is the building block of your golden parts.
Let's say your organization has a standard way to deploy a web application.
It needs a certain network configuration, specific identity and access controls.
Monitoring connected to your centralized logging, a security baseline applied, all of
that becomes a single module.
A developer doesn't write any of that themselves.
They reference the module.
They provide a few parameters, application name, environment, resource group.
The module handles everything else.
A module has a clear contract.
It accepts inputs, parameters.
What should the application be named?
What tier of resources do you need?
What region?
The module specifies exactly which parameters are required and what values are allowed.
It has outputs.
The resources it creates expose identifiers that other infrastructure can reference.
A database connection string, a service endpoint, a managed identity that the application
can use.
This structure makes modules composable.
One module can use another.
A landing zone module sets up networking.
A service module sits on top of that networking.
A deployment module orchestrates both.
Each has a clear input output contract.
Each is independently testable.
Each is independently maintainable.
Versioning transforms how infrastructure evolves.
A module isn't a static artifact.
It's versioned.
The organization releases version 1.0 of the web application module.
Teams adopted.
Months later, there's a security update.
Logging needs to be enhanced.
A compliance requirement changes.
The platform team releases version 1.1.
Teams that haven't updated still use version 1.0.
New teams use 1.1.
There's no forced migration that breaks everything.
No sudden change that requires rework.
Teams can plan their upgrade when it fits their schedule.
This is how you maintain consistency without rigidity.
The standard evolves.
But teams control their own pace.
Distribution through registries makes this scalable.
Bicep modules are published to Azure Container Registry.
Think of it like a package repository.
The platform team builds modules, test them, and publishes them to the registry with version
tags.
That's what the management teams discover those modules.
They pull specific versions into their infrastructure code.
They reference them.
The registry becomes the source of truth for approved standard patterns.
It's secure.
Only authorized teams can publish modules.
It's discoverable.
Teams can browse what's available.
It's governed.
You can see who uses which versions.
Track deprecation.
Enforced that old versions eventually get retired.
The final advantage is day zero support for new Azure features.
Azure releases new services constantly.
New capabilities.
New security features.
And as you are releases something, bicep supports it immediately.
Terraform providers often lag, sometimes weeks behind, sometimes months.
But bicep is Azure native.
When Microsoft releases a feature, bicep can use it the same day.
That matters for golden parts because it means your standard deployment templates stay
current.
New security capabilities get added to modules quickly.
New compliance requirements can be encoded immediately.
Your infrastructure standards evolve as fast as the platform itself.
This is the technical foundation that makes platform engineering possible at scale.
Modules as products.
This is where the thinking fundamentally shifts.
A bicep module isn't just a reusable piece of code.
It's a product.
It has users.
It has a life cycle.
It gets designed based on what customers actually need.
In the old model, modules are just maintenance artifacts.
Someone writes them to avoid repeating code.
They check them into a repo.
And they just exist.
If developers find them, they use them.
But nobody owns them.
If a module breaks, the first person who notices it has to fix it.
If the documentation is missing, you're on your own.
If it doesn't solve your specific problem, you just build a workaround.
That's where the model breaks.
This mindset creates technical debt at scale because you end up with dozens of similar modules
doing almost the same thing.
You get different naming conventions, inconsistent security baselines, and a mess of parameter structures.
A developer looking for a networking module finds three different options.
They pick one without really understanding it.
And then a week later, someone else builds a fourth version because they couldn't find
the first three.
Now you have redundancy.
You have inconsistency.
Every new hire walks into this chaos and has to guess which module is the actual standard.
The product mindset eliminates this.
When a module is a product, it has a clear owner.
Someone is responsible for the quality, the documentation, and the evolution of that code.
This owner understands the users.
They know what problems people are solving.
They track which versions are active and they communicate when a change is coming.
They are accountable for the module's success.
And because of that, the inputs and outputs become contracts that are honored.
When a module is just code, you can change it whenever you want.
You break the interface.
You add new requirements.
And you force everyone else to adapt.
And when a module is a product, the interface is sacred.
If you need to change how it works, you trigger a major version bump.
You give users time to plan the migration.
You provide clear notes on what changed.
And you keep things backward compatible as long as you can.
Users aren't surprised by breaking changes.
They plan for them.
This discipline creates consistency across the entire organization.
The module encodes your standards.
A database module always sets up backups based on your retention policy.
And it always configures monitoring to the company standard.
Every time a developer uses that module, they get those standards automatically.
They don't need to memorize the backup frequency or the tagging scheme, because the module already
made those decisions.
This is how you get consistency without forcing every developer to become a policy expert.
The separation of concerns is profound.
Platform teams own the modules.
They understand the infrastructure, the policy and the security baselines that need to be
enforced.
Product teams own the applications.
They understand the business problem.
And they just need infrastructure that works.
They pick a module, they provide the inputs and the infrastructure appears.
They don't need to know the internals.
They don't need to worry about compliance.
This eliminates duplicated work at an organizational level.
Without this structure, teams reinvent the same solutions over and over.
One team builds a backup logic for databases.
Another team does it for storage.
And a third team does it for apps.
It's the same problem solved three different ways.
That's tripled effort.
It's tripled bugs.
It's a tripled support burden.
With modules as products, you solve it once.
Properly.
You document it, you test it, and everyone uses it.
The effort is shared across the whole company instead of being wasted by individual teams.
The module becomes the interface that makes scale possible.
In a small shop, everyone can know everything.
But as you grow, that assumption fails.
You can't ask 500 developers to master infrastructure, and you can't ask 100 operators to understand
every app.
You need clear boundaries.
Modules are the tools that bridge those boundaries.
They allow an organization to grow from being small and coordinated to being large and
distributed.
They let you maintain consistency without requiring everyone to work exactly the same
way.
And that's why treating them as products matters.
Azure verified modules, AVM, as the standard.
Building modules from scratch is expensive.
You have to design them, test them, and document them.
You have to maintain them and debug them when they fail in production.
If you're starting this process for the first time, it takes months.
You're looking at six to nine months just to get a solid baseline for your most common
scenarios.
And even then, you're probably just reinventing things Microsoft solved years ago.
You're duplicating effort that's already been done by thousands of other companies.
Azure verified modules changed this equation entirely.
AVM isn't a collection of example templates.
It's a Microsoft curated library of production ready bicep modules.
These are modules that Microsoft designed and tested extensively so that enterprises
could use them as a foundation.
They looked at the patterns that repeat across every organization from security baselines
to networking standards, and they codified them.
Then they published them for everyone.
The modules follow strict patterns that make them predictable.
When you pull down an AVM module for a storage account, you already know what it looks like.
The parameters and outputs follow a naming convention that matches every other module
in the library.
This consistency matters.
Once a developer learns how one AVM module works, they can use any of them.
The input patterns are the same.
The documentation is the same.
The learning curve just disappears.
And these modules are battle tested at scale.
They aren't theoretical.
They've been used by Microsoft internally and by massive enterprise customers.
Bugs have been found and fixed.
When Microsoft releases a new feature that changes how a resource works, the AVM modules get
updated to account for it.
You aren't adopting code that's going to be abandoned.
You're adopting a foundation that Microsoft actively maintains.
This means organizations don't have to start from zero anymore.
The old way was to decide on a pattern, build it, test it, and then deploy it.
That's months of work.
With AVM you start with what's already built.
Your organization needs networking, identity and logging.
AVM already has those modules.
You adopt them.
You add your specific layers on top and you move on.
You aren't building from scratch.
You're customizing something that's already proven.
This accelerates your governance baseline dramatically.
Defining which resources are allowed and how they should be configured usually takes
a long time.
You have to design the policy and refine it based on mistakes.
With AVM the baseline is already there.
It aligns with the cloud adoption framework.
It incorporates security best practices and compliance patterns for regulated industries.
You adopt the framework.
You add your own requirements and months of work turn into weeks.
The modules are aligned with how Microsoft recommends you build.
The cloud adoption framework is the gold standard for enterprise cloud strategy.
AVM modules implement those calf patterns directly.
When you use them, you aren't just getting code.
You're getting a platform that's built for the long term.
Your infrastructure won't just work.
It will work the way Microsoft recommends large organizations structure their cloud.
This is how enterprises avoid reinventing the wheel.
Every company thinks their situation is unique.
But the core patterns are almost always the same.
Before you connect networks and manage identity doesn't change that much from one company
to the next.
AVM solved those problems once with security and scale in mind.
Using those solutions means you aren't wasting time on work that's already been done
well.
You're leveraging a foundation that works so you can focus on your specific business problems.
The leverage here is enormous.
An organization with hundreds of developers can save thousands of engineering hours by adopting
AVM.
Those are hours not spent building modules or debugging homegrown patterns.
Those are hours you don't have to spend explaining your custom approach to every new
hire that time compounds.
And it's time the organization can spend on actual innovation instead of rebuilding the
basement.
That's the value AVM brings.
Policy as code and governance automation as your policy is the enforcement layer that
makes everything else work.
It defines what is allowed and what is forbidden in your environment.
You can mandate that storage accounts have encryption enabled or that resources only exist
in specific regions.
You can require managed identities for database access block public IP addresses or mandate
specific tags.
As your policy is the system that checks if your resources actually follow those rules.
But in reality traditional policy enforcement is just a gate at the end.
You deploy infrastructure then someone a security officer or an architect reviews it.
They check for encryption.
They look for tags.
They verify the region.
If something is wrong, they reject the deployment.
You fix it.
You resubmit.
They review it again.
The process is slow and it is external to the infrastructure itself.
The infrastructure has no idea the policy exists.
Policy is just something that happens to the resources after they are already there.
It is called the policy as code flips this relationship.
Instead of a separate review, you codify the policy and deploy it like any other piece
of software.
You write definitions.
You version them.
You review them in pull requests.
Once that policy is live, it applies to everything in its scope automatically.
You cannot deploy something that violates the rules because Azure will not allow the
deployment to start.
The check happens at the moment of deployment, not weeks later.
This is a structural shift that changes everything.
When policy is code, it becomes maintainable.
A security team can own policy definitions the same way a platform team owns modules.
As requirements change, the policy gets updated and deployed.
Other teams do not need to memorize new rules.
The new policy just works.
There are no announcements, no training sessions, no emails telling everyone to adjust their
infrastructure because compliance requirements changed.
Bicep makes encoding this policy into modules feel natural.
Bicep modules are the building blocks of your infrastructure.
When you use a module, you are referencing a reusable pattern.
The author of that module can bake compliance directly into the code.
A storage module always enables encryption and always applies the right logging.
The developer does not even have to think about it.
The module already accounted for the rule.
This makes governance a property of the infrastructure, not something external.
When you use a compliant module, the infrastructure is inherently compliant.
You cannot misconfigure it because the module does not allow that option.
The security baseline is embedded.
The logging is pre-configured.
The developer follows the golden path and compliance just happens.
Compare this to the old model.
A developer writes code.
Someone reviews it.
Issues are found.
The developer does not understand the policy, so they guess at a fix and resubmit.
The reviewer still sees problems more back and forth.
Frustration builds.
Eventually, it passes, but the developer still does not know why certain settings matter.
Next time they will make the same mistakes.
With modules, the developer does not make the mistake in the first place.
Understanding policy is no longer their responsibility.
It is built into the pattern.
This removes the most painful part of governance, the cycle of rejection and resubmission that
makes developers hate the security team.
Some compliance becomes architecturally impossible.
This matters for the culture of the team.
In the old model, compliance is a constraint.
It is something imposed on you that you try to work around.
With built-in compliance, it is just how the system works.
You are not fighting the rules.
You are building on a solid foundation.
The enforcement happens silently.
A developer deploys their code.
They do not get a violation report or a flag in an audit.
They simply could not have violated the policy if they tried.
The module prevented it.
The policy prevented it.
Everything that exists was always compliant from the start.
This closes the gap between what you have deployed and what your policy requires.
In traditional setups, there is always drift.
You find resources that do not match the rules or exceptions that were never documented.
Compliance becomes a game of catch-up.
You end up with a score like 80% compliant and you spend all your time trying to fix the
other 20%.
When policy is in the modules, new infrastructure is compliant by design.
The compliance problem becomes a legacy problem.
As teams move to the new modules, your score rises.
Eventually, it hits 100% because new deployments are never wrong.
This is how you scale governance without scaling the bureaucracy.
The shift from tickets to templates.
The mechanical difference between these two models is stark, but the structural difference
is what actually matters.
In the traditional ticket-based system, there is an approval gate.
A developer needs a database.
They write a request.
They describe what they need.
That request goes into a queue and waits.
Eventually, someone picks it up.
They might need more info, so they send it back.
This goes back and forth until it is clear, then they approve it, then the work starts.
The infrastructure gets built, tested and handed over.
The approval gate creates a dependency.
The developer is blocked.
Waiting for a yes.
The operations person is a bottleneck for the whole company.
Neither side controls their own time.
The developer is waiting, and the operations person is overloaded.
Because everything is in a queue, even a five-minute task takes three days.
The template-based system removes the approval gate entirely.
There is no request.
There is no queue.
A developer goes to a portal and sees a list of templates.
They pick one.
They fill in the name, the environment and the region.
They see a summary of what will happen and they click deploy.
The infrastructure starts building immediately.
No human approval is required.
This only works because the template already holds all the decisions that used to be manual.
The security baseline is in the code.
The compliance rules are baked in.
The decisions were made once.
When the template was created, there is nothing left to approve.
The template either matches the standard or it does not exist in the catalog.
This is the structural shift.
When the approval model, every deployment is a unique event.
A developer makes choices and someone has to judge those choices.
Someone has to verify the securities.
Someone has to make a call on whether the deployment is acceptable.
In the template model, the developer makes no infrastructure decisions.
The template made them.
Those decisions were validated and approved months ago.
When a developer uses that template, they inherit those approvals.
The bottleneck disappears because there is nothing left to review.
This frees the operations team to do real work.
In the ticket model, operations people are just processes.
They spend their lives reading requests, asking questions and manually clicking buttons.
The work is reactive.
You are always responding to someone else's calendar.
In the template model, the operations team becomes a product team.
They spend their time studying common patterns and building templates to solve them.
They test the code.
They update the modules when the companies need change.
The work is proactive.
You are not answering tickets.
You are anticipating needs.
This is a total shift in what the team actually does.
Instead of being a human firewall, you are building self-service tools for your customers.
This work is more strategic and much more interesting.
It is where you actually get to innovate instead of just surviving the inbox.
The amount of time you save is massive.
A typical team might handle 10 requests a day and each one takes hours of talking and
building.
That is thousands of hours every year spent on reactive tasks.
When you kill the request process, those hours come back.
The team can now improve the templates or build new ones as new tech emerges.
The work becomes worth doing.
The infrastructure itself gets faster too.
When you build from a ticket, you are careful because you are dealing with uncertainty.
You over-provision because you aren't sure what the developer needs.
You test slowly because you don't want to hand over a broken environment.
It is a cautious, slow process.
With templates, the provisioning is automated.
A template deploys in minutes with no manual steps and no hand testing.
The time from "I need this" to "it's ready" drops from days to seconds.
The developer starts their work immediately.
The template model takes a manual, gated process and turns it into something instant.
Cognitive load reduction metrics.
Cognitive load is real.
But it's invisible.
You feel it.
Engineers experience it every day.
But if you can't measure it, you can't prove it exists.
And if you can't prove it exists, leadership won't fund the platform work needed to fix it.
So what's actually happening is we're trying to measure something as abstract as mental
effort.
The only way to do that is through indirect measurement.
By looking at the observable effects of that burden, start with time to first deployment.
When a new engineer joins the team, how long does it take them to ship their first change
to production?
In most organizations, without a solid platform, this takes two to four weeks.
The engineer spends the first week just learning tools, the second week trying to understand
infrastructure and the rest of the time, getting stuck on policies they don't understand.
But with a platform built on golden paths, that timeline collapses.
First deployment happens in days.
Or even hours.
The engineer uses a template, follows the path and the infrastructure just works.
This metric directly reflects a drop in cognitive load because less time spent on the how
means more mental energy for the what.
Environment provisioning tells a similar story.
In traditional setups, getting a dev environment ready means submitting a request and waiting
for manual approvals.
The engineer's mental load stays high because they're stuck in uncertainty, switching to other
tasks while they wait for operations to finish with self-service infrastructure that same process
happens in minutes.
The engineer hits a button, the platform provisions everything and the access just appears.
No waiting.
No context switching.
No uncertainty.
The load drops because the task is finally simple and fast.
Then there are support tickets.
These measure the friction that doesn't show up in deployment stats.
How many times does an engineer need help with a routine task?
Why did my compliance check fail?
How do I configure identity?
When you reduce cognitive load, these tickets disappear.
It's not because your engineer's got smarter.
It's because the platform eliminated the need for help in the first place.
The template solved the problem before it started.
Context switching is harder to track, but it's the real focus killer.
In a messy environment, one deployment might force an engineer to jump between five different
systems.
Force control, CI/SWRCD, infrastructure code, policy checkers, every switch breaks their
attention and resets their mental model.
A well-designed platform stops the bleeding by keeping everything in one flow.
To track the human side of this, use the space framework.
It breaks developer satisfaction into five areas.
Like well-being, performance and flow.
These aren't just feel-good metrics.
They're data points you validate against actual work outcomes.
You should also track your developer net promoter score for the platform itself.
Ask them, would you recommend this platform to appear?
A high score means you've actually solved their problems.
A low score means you're just adding more friction.
The most compelling case for an executive is combining time to first PR with satisfaction.
When you can show that new hires ship code in three days and 90% of them say the platform
makes work easier.
The argument is over.
You aren't talking about abstract feelings anymore.
You're showing faster onboarding and measurable productivity.
Research shows that platforms designed this way can cut the mental effort required
for the same work by nearly half.
That's the quantification that justifies the investment.
The business case, productivity and retention.
This is the moment where platform engineering stops being a technical choice and becomes
a business imperative.
The gains here are measurable in the financial terms that CFOs actually care about.
Every tiny improvement in the developer experience index saves about 13 minutes per developer
every week.
That sounds like nothing.
But for a 100 person team, that's $100,000 in reclaimed capacity every year.
That is a developer you didn't have to hire.
When you scale that to a thousand person organization, you're looking at a million dollars in
save time.
These aren't theoretical numbers.
They represent the hours people spend on real work instead of fighting the system.
But the true impact goes way beyond just saving hours.
Onboarding time is a massive part of hiring economics.
In the old model, you pay a senior salary for weeks, while a new hire contributes nothing
to the business.
The salary is just an expense with no return.
When you compress that onboarding from a month down to three days, you're accelerating
the value of that hire.
In a market where talent is expensive, getting someone productive in days instead of weeks,
changes the math on every person you bring in, you're essentially getting a massive head start
on your revenue for every new seat.
Retention economics are even bigger.
Replacing a senior engineer who quits costs roughly $250,000.
That includes recruitment fees, the gap in productivity, and the time spent training
a replacement if your engineers are leaving because of burnout and infrastructure friction.
You are paying that quarter million dollar penalty over and over again.
And the platform reduces that frustration, people stay.
The organization keeps its knowledge and avoids the massive cost of turnover.
This is especially true for your most senior people.
They are the ones most likely to leave when the operational friction gets too high.
Losing them isn't just losing a salary.
It's losing the organizational context and the multipliers who keep everyone else moving.
Most platform investments deliver a two to five times return within two years.
That return comes from smaller hiring needs, better retention, and faster feature delivery.
It's not a guess.
It's a documented range from companies that have already made the shift.
But here's the problem.
Most engineering teams talk about deployment frequency.
CFOs don't care about deployment frequency.
They care about revenue and retention.
The translation between those two worlds is what gets your platform funded.
If you can prove the platform will cut turnover by 20% and save $2 million in replacement
costs.
You've made a business case, not an engineering case, a business case.
This is why your metrics matter so much.
If you only measure door metrics, you'll struggle to justify the spend.
But if you measure retention, time to productive.
And hiring costs.
The investment becomes obvious.
Platform engineering isn't an expense you have to manage.
It's an investment in how your company functions.
It's how you scale your output without scaling your head count.
And how you turn your infrastructure into a competitive advantage, Bula.
Adoption and the product mindset.
The most dangerous assumption in platform engineering is simple.
If you build it, they will use it.
In reality, they probably won't.
You can build an elegant platform with golden paths and automated governance.
You can even set up an internal developer portal with perfect documentation and templates.
But developers will still find workarounds.
They will use their own scripts.
They will ask for exceptions.
They will find every possible way to avoid your platform entirely.
This happens constantly.
Organizations launch a new platform and the adoption metrics look healthy on paper.
80% of developers have access, so the spreadsheet says it's a success.
But then you look at actual usage.
Maybe only 30% of developers used it this week.
Only 20% of services went through the platform.
The rest of the organization used manual processes and workarounds.
This is the adoption trap.
It kills most platform initiatives before they can prove their worth.
The platform didn't fail because of the technology.
It failed because it didn't solve the problems developers actually cared about.
Maybe the templates were too rigid for real work.
Maybe they didn't fit how teams actually operate on a daily basis.
Maybe the documentation assumed knowledge that new engineers didn't have yet.
Whatever the reason developers chose alternatives.
The platform became theater, present but powerless.
But here's the problem.
You can't force adoption.
You can create policies and make it the official company standard.
And if it doesn't solve problems better than the alternatives, people will circumvent the rules.
Force adoption creates resentment, not usage.
The real solution is treating the platform as an actual product.
A product isn't something you build once and maintain.
It's something you design based on what customers actually need.
You build a minimum version.
You release it.
You watch how people use it.
You talk to them about friction.
You ask what's confusing or what didn't work the way they expected.
Then you iterate.
This requires a different structure.
You need a product manager whose entire job is to understand what developers need.
Not what they say in a survey, but what they actually need based on how they work.
This person watches how people use the platform to understand adoption patterns.
They know which templates are used constantly and which ones nobody touches.
You need user research before you build anything.
You don't want templates designed in isolation by infrastructure engineers.
You want them designed by understanding the constraints developers face every day.
This research informs the design.
You build what matters.
And you need feedback loops.
When you launch a new capability, you measure if it's actually being used.
You talk to the teams that didn't adopt it and ask what would have made it useful.
You don't just build a feature and assume it's valuable.
You validate it.
Someone has to be accountable for the platform's success.
Not just that it's technically sound, but that developers choose to use it.
Success is measured by adoption and satisfaction.
Not by how many features you shipped.
The product mindset changes how decisions get made.
When you treat infrastructure as code, you optimize for technical elegance and clean
architecture.
But when you treat the platform as a product, you optimize for developer experience.
These priorities conflict.
A technically elegant solution might be complex to use.
A simple solution might have architectural compromises.
With a product mindset, you choose simple.
Adoption matters more than perfect architecture.
You can refactor later.
But you can't succeed if nobody uses it.
This shift from engineering discipline to product discipline is what separates platforms
that work from platforms that just exist.
It's not about the technology.
It's about whether the platform solves problems that developers care about enough to choose
it over alternatives.
By-set modules in enterprise governance.
When you're building for 50 developers, governance is a conversation.
When you're building for 5,000, it's an operating model.
By-set modules are how you make governance scale without it becoming paralyzing.
Enterprise governance has a fundamental tension.
You need consistency for security and compliance, but you also need flexibility because different
business units have different requirements.
A governance model that's too rigid will always be circumvented.
Teams will find ways around it and you end up with shadow infrastructure that skips
governance entirely.
By-set modules solve this by making governance layered and composable.
At the foundation are landing zones.
A landing zone is a baseline environment that defines what a subscription looks like before
any application is deployed.
This includes the network foundation and identity configuration.
It includes the logging baseline to make sure diagnostics go to a central location.
This baseline is encoded in a by-set module.
When a new subscription is provisioned, it starts with the landing zone already applied.
On top of that site, policy modules.
These define organizational standards for specific concerns.
But making sure storage accounts always have public access denied.
They ensure databases have automated backups and monitoring enabled by default.
Each policy is a separate module that encodes a specific requirement.
Then you have R-back modules that standardize how access works.
Applications don't get admin access.
They get specific roles for specific operations.
A web application can read from a database but can't modify the schema.
These patterns are standardized in a by-set module that every team uses.
Access stays consistent across the entire organization.
These modules compose into larger patterns.
A data analytics landing zone builds on the base but adds networking for data connections
and specific security controls.
Each is built from the same library.
But they are combined in different ways based on specific needs.
This is how you get consistency without rigidity.
The modules enforce minimum standards but they are parameterized.
Teams can choose the performance tier or the retention period they need.
The module enforces that identity access works a certain way, but it allows teams to decide
which identities get which roles.
Scaling this is the real challenge.
An organization with hundreds of subscriptions managed manually would require a massive governance
team.
You would need hundreds of people reviewing configurations and verifying compliance.
By-set modules eliminate most of this work.
New subscriptions don't need manual review because they deploy with the landing zone module.
Compliance is built in.
Resources that don't use approved modules trigger violations at deployment time.
It's automatic enforcement.
This scales governance without scaling the bureaucracy.
In a manual world, the governance team becomes a bottleneck.
More teams mean more reviews and more monitoring.
With module-based governance, you build the modules once and they scale across the organization
with minimal effort.
This is also how you avoid security drift.
In manual governance, you might verify compliance at one point in time, but over time configurations
drift as teams make changes.
With module-based governance, drift is largely impossible.
Resources that don't follow the pattern simply fail to deploy.
The system enforces compliance continuously.
Not through periodic audits.
By-set modules make enterprise governance practical.
They make it standardized, scalable and transparent to the teams building on top of them.
By-set versus terraform, the strategic choice.
This is where strategy matters more than technology.
You have to make a choice about your ISE tooling.
And while that choice feels technical, it's actually about your business direction.
By-set versus terraform, which one is better?
Which one should you standardize on?
But the real question isn't technical.
It's strategic.
What's your cloud commitment?
How does your organization think about infrastructure?
What constraints matter most?
Automatism is multi-cloud.
It uses the same language and tooling across Azure, AWS, GCP and Kubernetes.
You write terraform code for your networking layer on AWS and then you use those same patterns
for your networking on Azure, same syntax, same team.
This matters for organizations that genuinely operate across multiple clouds.
You don't learn one language for AWS and another for Azure.
You learn terraform once and use it everywhere.
By-set is Azure native.
It designs specifically for Azure infrastructure.
It doesn't pretend to be multi-cloud.
It's not trying to be a general purpose tool that works everywhere.
It's a tool built for Azure by people who understand Azure deeply.
That focus creates advantages.
By-set has day zero support for new Azure features.
When Microsoft releases a new service, By-set can use it immediately.
Terraform providers often lag, sometimes weeks, sometimes months.
If you need the latest Azure feature for a security requirement, Terraform might not support
it yet.
This lag matters.
It's not just an inconvenience.
If you're building your governance baseline and you need a new Azure policy feature,
Terraform doesn't support it yet.
You're blocked, you can use By-set or you can wait for Terraform.
That dependency on a third party's timeline for your critical infrastructure is a real constraint.
For organizations that are Azure only, By-set is increasingly the default.
If your cloud strategy is Azure and it's going to stay Azure, why constrain yourself to
a tool optimized for multi-cloud parity?
By-set is optimized for Azure.
It's simpler.
It's more closely integrated with Azure native governance.
It supports new features faster.
Your modules are cleaner.
Your team can focus on Azure expertise instead of learning patterns that work across clouds.
The trend is clear.
New Azure focused organization standardize on By-set.
Existing organizations that have invested heavily in Terraform, sometimes stick with it because
migration costs are high.
But greenfield decisions in Azure-centric organizations increasingly choose By-set.
For organizations with genuine multi-cloud needs, Terraform remains the standard.
If you're running infrastructure on AWS and Azure and GCP, you need consistency.
You need teams that can move between clouds without relearning tools.
You need your networking patterns to work the same way everywhere.
You need policy enforcement that's cloud agnostic.
Terraform gives you that.
It's the common language.
Terraform governance tools work across providers.
Your remote state backend pattern is the same on all clouds.
Your module library patterns are identical.
The cost of maintaining multiple IAC languages, Terraform here, cloud formation there, By-set
somewhere else is higher than the cost of constraining yourself to Terraform's model.
You choose Terraform not because it's the best for any single cloud.
It's good for all clouds.
That's the value.
Consistency.
A single way of thinking about infrastructure regardless of where it runs.
Hybrid approaches are becoming increasingly common.
Some organizations use By-set for Azure-specific infrastructure and governance.
Landing zones, policy modules, security baselines, Azure-native patterns that you want day-zero
support for and deep integration with Azure-policy.
But they use Terraform for cross-cloud concerns.
Global networking, shared identity patterns, services that span multiple clouds.
The organization uses both tools with clear boundaries.
By-set owns Azure governance, Terraform owns cross-cloud orchestration.
This approach requires discipline.
You need clear boundaries.
Which team owns the By-set modules?
Which owns the Terraform infrastructure?
How do the two integrate?
What's the deployment order?
But when the boundaries are clean, it works.
You get the benefits of both approaches.
Azure-native velocity from By-set and multi-cloud consistency from Terraform.
The choice isn't about which tool is objectively better.
It's about matching the tool to your strategy.
What your organization's cloud commitment actually is.
Ask whether you have genuine multi-cloud needs or whether Azure is your primary platform.
Ask what timeline matters for new feature adoption.
The answers to those questions determine the right choice.
Not the technology, the strategy.
Module registries and distribution.
Distributing modules is the problem that looks simple until you try to scale it.
When a team writes a By-set module and stores it in their Git repository, distribution is
straightforward.
Other teams can access the Git repo.
They reference the module.
It works.
You scale beyond a few teams, Git-based distribution becomes unwieldy.
Teams don't know what modules exist, where they stored, who maintains them.
Which version are they using?
Is there a newer version available?
The module becomes scattered, duplicated, versions diverge.
Teams maintain separate copies and diverge from the organizational standard without realizing
it.
This is where registries change everything.
A registry is a central location where modules are published, versioned and discovered.
Azure Container Registry is the natural choice for By-set modules.
It's native to Azure.
It's built for storing and managing artifacts.
When a platform team finishes building and testing a module, they publish it to the registry
with a version tag.
Now it's discoverable.
Teams can find it.
They can see all available versions.
They can pull the specific version they need into their infrastructure code.
The registry becomes the source of truth for organizational standards.
When a team wants to know how the organization deploy storage accounts, they don't search
across repositories.
They look in the registry.
The storage module is there.
It has documentation.
It has examples.
It shows the current version and any previous versions.
They can see the difference between version one and two.
They understand what changed.
They decide whether to upgrade or stay on their current version.
The registry is not just a place to store code.
It's the place where organizational patterns become visible and discoverable.
This visibility alone changes adoption.
Teams use modules not because they're forced to.
They use them because they can find them and because they are cleaner than building from
scratch.
When everything is scattered across repositories, teams don't find the module that already
exists and they build their own.
When everything is in the registry, teams find it immediately.
Search increases, duplication drops.
Semantic versioning in the registry prevents silent breaking changes from destroying infrastructure.
When you publish a module to a registry with a version tag, that tag is immutable.
Version 1.0 never changes.
If you need to make a change to the module, you increment the version.
A bug fix becomes version 1.0.1.
A new parameter becomes version 1.1.
A breaking change becomes version 2.
Teams using version 1.0 keep using version 1.0 unless they explicitly choose to upgrade.
They're not suddenly broken because the module changed.
The registry enforces this.
Old versions stay available.
New versions exist alongside them.
This matters profoundly for large organizations.
Imagine 500 deployments across the organization using a storage module.
The module is upgraded to fix a bug.
Without version control, every deployment gets the new version.
If there's an unexpected consequence, you broke 500 things simultaneously.
With versioned registries, no deployment changes unless the team explicitly upgrades.
You release the new version.
You communicate what changed.
Teams evaluate whether to upgrade.
Some upgrade immediately, some wait, some never upgrade because they're happy with the
current version.
Upgrades are deliberate, not automatic.
You control your own fate.
Access controls on the registry ensure governance is enforced at distribution time.
Not everyone should be able to publish modules to the registry.
Publishing a module means establishing a standard that other teams will follow.
This should be controlled.
You define who can publish.
Maybe only the platform team.
Maybe the platform team and approved infrastructure teams.
Publishing requires code review.
It requires testing.
It requires documentation.
Teams can't just push modules.
The registry enforces governance at the source.
Only approved, tested, documented modules get published.
Teams consuming modules know they're getting something vetted.
This scales the governance burden horizontally across the organization.
Instead of vertically on a small group, every team using the module benefits from it.
If there's an issue, the platform team fixes it once.
The fix propagates.
But low quality or non-compliant modules never enter the registry because the gate is
enforced before publication.
The registry model scales from dozens of modules to thousands, as the organization grows
modules accumulate.
They don't become a chaos problem because they're organized, versioned and governed.
New teams discover what already exists.
Adoption accelerates.
Organizational standards compound and strengthen over time.
CI/CD integration and automation.
The magic of platform engineering isn't in the modules themselves.
It's in how they get deployed.
A module sitting in a repository is just code.
A module in a CI/CD pipeline is an organizational standard.
Think about the workflow for a developer using a golden path module.
They write the bicep file.
They reference the registry.
They plug in the parameters, application name, environment, region.
Then they push the code.
At that moment, the pipeline takes over.
Everything that follows is automated enforcement.
First, the pipeline validates the syntax.
It checks if the bicep code is valid and if the module actually exists.
This happens before a single resource is touched in Azure.
If there's a syntax error, the pipeline fails immediately.
The developer sees the error, fixes it and pushes it again.
It sounds basic, but it's powerful.
Errors are caught at the desk, not in production.
Next the pipeline runs security scans.
The infrastructure code is examined for vulnerabilities, public IPs where they shouldn't be.
Missing encryption, overly broad access.
The scans are automatic.
If an issue is found, the deployment stops.
The developer sees exactly what's wrong and fixes it right then.
The pipeline simply doesn't let non-compliant infrastructure through.
Then come the policy checks.
The code is validated against Azure policy.
Does it match the organization requirements?
Is it using approved resource types?
Is it in the right region?
Does it have the required tags?
The developer doesn't need to be a policy expert.
The pipeline handles the validation.
If a violation occurs, the deployment stops.
The default state is that the pipeline prevents non-compliance.
This is the structural difference from traditional workflows.
In the old model, a human reviews the code.
That review is subjective.
Different reviewers make different decisions.
The process is slow.
You submit, you wait.
The reviewer reads it.
They ask for clarification.
Back and forth.
A bottleneck.
In the automated model, the pipeline runs the checks.
The same checks every time.
Consistent, fast.
The developer gets feedback in minutes.
They know exactly what failed.
There is no subjective judgment or waiting for an email.
The policy is code.
The result is deterministic.
This shift left approach is profound.
Compliance happens at build time.
The developer sees the violation while they are still focused on the change.
They fix it before the problem ever exists in a real environment.
Automated testing also protects the modules themselves.
When a module is updated, the tests run.
Does it deploy?
Does it apply the correct policy?
Do the outputs match the documentation?
These tests run every time someone changes a module.
If anything breaks, the change is rejected.
No-con modules never reach the registry.
This also prevents drift.
A module that worked six months ago still works today.
If an Azure update invalidates a setting, the tests catch it.
The maintainer knows immediately that an update is required.
Automation reduces human error to near zero.
Humans, forget steps.
Humans make typos.
Humans take shortcuts when they're tired.
Pipelines don't.
They don't skip steps because they're in a hurry.
They don't apply policy differently on a Friday afternoon.
Consistency is enforced.
Reliability goes up.
This eliminates the approval bottleneck entirely.
There is no person standing between the developer and the cloud.
The pipeline is the approver.
If the check's passed, it deploys.
If they fail, it doesn't.
No human needed.
No queue.
No waiting.
The developer submits.
The pipeline runs.
And the result appears minutes later.
That is how you break the ticket-based model with.
The operational shift from gatekeeper to enabler.
The biggest change in platform engineering isn't technical.
It's cultural.
And that shift happens inside the operations team.
In the traditional model, the ops team is a protector.
Their job is to stop bad decisions.
Developers want to build.
Ops decides if it's allowed.
Is it secure?
Is it compliant?
Will it break something?
Ops acts as a gate.
Approve or deny.
The mindset is defensive.
Success is measured by how well you prevented things from going wrong.
That model made sense when infrastructure was expensive.
When a server took weeks to arrive and cost thousands of dollars, you needed a gatekeeper.
You couldn't have developers spinning up hardware carelessly.
The gate prevented waste.
But that context is gone.
Infrastructure is now cheap and fast.
A developer can build an entire environment in minutes.
The old gatekeeping doesn't protect against waste anymore.
It just creates friction.
The developer still needs the resources.
Ops still says yes or no.
Nothing has changed except the level of frustration.
Platform engineering inverts this role.
Instead of approving requests, ops builds products.
Instead of saying no, ops says yes automatically
by encoding decisions into the platform.
Instead of reviewing deployments, ops build systems that enforce standards.
This requires a completely different skill set.
A traditional ops person is good at policy and risk evaluation.
Platform engineer is good at product design.
They understand what developers need.
They build tools that solve problems.
They make the right way, the easy way.
It's a different way of thinking.
Gatekeepers think about control.
Platform engineers think about enablement.
This shift is harder than it sounds.
Many teams have spent decades as gatekeepers.
It's what they know.
It's how they feel competent.
Switching to enablement can feel like a loss of authority.
It can feel like the organization doesn't trust them.
But it's actually the opposite.
The organization is asking them to solve a much harder problem.
Not is this deployment okay or?
How do we build a system where a bad deployment is impossible?
The metrics change to reflect this.
In the old model, success was tickets closed.
How many requests did we process?
How many approvals did we give?
In the platform model, success is adoption.
Do developers use the platform?
Do they like it?
Does it actually solve their problems?
It's harder to measure.
It's easier to count tickets than it is to measure satisfaction.
But it's more meaningful.
A team that closes a thousand tickets
but leaves developers frustrated is failing.
A team that enables self-service and delivers value is succeeding.
The role becomes strategic.
Instead of reacting to tickets, the team anticipates needs.
They study how developers work.
They identify pain points.
They iterate based on feedback.
It's product work. It's proactive.
This also changes career paths.
In the old world, you became senior
by having better judgment on approvals.
In the new world, you become senior
by building products that more teams adopt.
Scenority comes from enabling work, not controlling it.
The results are profound.
Ops teams that make this shift become more engaged.
They are solving interesting problems
instead of being a human firewall.
They are building instead of preventing.
Even though the ops team has less control,
they become more valuable.
Because now, they are the engine
that allows the entire company to move faster.
Measuring platform ROI.
Measuring the success of a platform is difficult
because no single metric tells the whole story.
You need multiple angles.
Each one reveals something different.
And together, they create a picture
that executives actually understand and fund.
Start with door metrics.
These are the most concrete numbers you have.
You look at deployment frequency
to see how often you release to production
and you track lead time for changes
to measure the gap between a code commit and going live.
Then you monitor the change failure rate
to see what percentage of deployments cause incidents,
alongside the mean time to recovery
to see how fast you fix problems when they happen.
These are operational metrics that show how fast
and safely your organization ships software.
When you implement a platform,
these numbers typically improve.
Deployment frequency usually increases
while lead time drops because golden paths eliminate
the friction that used to slow your teams down.
The pipeline automates what used to require manual approval
and that shift shows up immediately in the data.
But door metrics alone are incomplete.
You can improve deployment frequency
by shipping small, low risk changes constantly,
which is a good thing.
But if your developers are miserable
and the organization is burning out engineers
to achieve that speed, you haven't actually solved anything.
The platform has just created the wrong kind of velocity.
This is why you need satisfaction metrics
alongside delivery metrics.
Developer satisfaction tells you
whether people actually value what you built.
A net promoter score for the platform
is a simple question that captures adoption intent.
When developers love the platform, the NPS is high.
When they resent it or see it as bureaucracy,
the NPS is low.
A high score tells you the platform is solving real problems.
While a low score tells you the platform is just friction,
regardless of what the deployment metrics say.
Adoption rate completes this picture.
Our developers actually choosing to use the platform.
You need to know what percentage of new services
are deployed through the golden paths
and how many teams use the self-service capabilities.
Adoption shows whether developers believe the platform
is worth using, you can't force adoption.
You can mandate it.
But developers will always find workarounds.
When adoption is high and voluntary,
it means the platform is genuinely valuable.
Time to first deployment measures a specific friction point.
How long does it take for when a new engineer starts
until they ship their first production change?
In organizations without a platform, this often takes weeks.
With a platform and solid golden paths,
it compresses to days or even hours.
This metric directly translates to onboarding cost
and time to productivity.
Short time to first deployment means new hires are valuable sooner
and it serves as a concrete proxy for whether the platform
is actually reducing cognitive load.
Cost avoidance metrics quantify the financial impact.
Fewer incidents mean less firefighting
and less lost productivity.
Fewer support tickets mean the platform team spends
less time answering routine questions.
Less manual infrastructure setup means
ops teams focus on innovation instead of repetitive provisioning.
These savings are real.
They are hard to measure precisely, but they are substantial.
An organization that previously spent 50 hours a week
on manual infrastructure setup
and now spends five hours is avoiding 45 hours of waste.
If you multiply that by labor cost,
you have a real financial saving.
The power emerges when you combine these metrics
into a single narrative.
Tell executives that deployment frequency increased 40%
while lead time dropped from three days to eight hours.
Developers satisfaction with the platform
improved from 40 out of 180.
90% of new services use the golden paths.
Time to first deployment dropped from four weeks to three days.
Support requests decreased by 60%
and incidents involving infrastructure
misconfiguration dropped by 70%.
That is a complete story.
Speed improved, quality improved.
People are happy, adoption is high.
Developers are choosing this approach
and the organization is saving money.
This is how you justify continued investment.
Not because the technology is elegant,
but because the organization is measurably better
as a result of the platform.
The metrics must be tracked continuously.
This isn't a one-time assessment.
Every quarter you should publish the numbers
and show the trends.
Did adoption increase this quarter?
Did satisfaction improve?
Did lead time continue to decline?
Transparency builds confidence
that the platform is delivering value.
It also guides the platform team.
If adoption's stalled, that is a signal.
If satisfaction dropped, something needs fixing.
The metrics are feedback.
They tell you whether you are building the right things.
Executives understand this language,
not door or metrics alone
and not satisfaction surveys alone.
The combination speed and people and adoption
and cost avoidance together.
That is how you prove platform ROI.
Overcoming common adoption barriers.
Platform initiatives fail more often
from execution than from concept.
The problems aren't technical.
They are structural and they are predictable.
The first failure mode is over-engineering
before you know what developers need.
Platform teams get excited.
They build full solutions and design intricate governance
systems.
They create elaborate permission models
and build portals with hundreds of features.
They release the platform and wait for adoption,
but it doesn't come.
The platform is too complex.
Too many features confuse instead of clarify.
Too many options paralyze instead of enable.
Developers don't know where to start.
They go back to doing things manually
because manual is simpler than understanding the platform.
This happens because platform teams
engineer in isolation.
They don't talk to developers before building.
They don't watch how developers work.
They don't iterate based on feedback.
They design what they think developers need.
And then they are surprised when developers don't want it.
The fix is to start small.
Build the minimum viable platform
that solves one real problem, one golden path,
one template, one service.
Get it in front of developers and watch how they use it.
Talk to them about friction.
Does it solve the problem you intended?
Is it easier than the alternative?
What would make it better?
Then iterate.
Build the second template based on what you learned.
Keep the scope bounded until you understand
what developers actually value.
The second failure mode is treating the platform
as infrastructure instead of as a product.
This manifests as platform teams building systems,
but not caring whether people use them.
They focus on technical excellence, clean architecture,
proper separation of concerns.
The platform is technically elegant, but nobody adopts it.
The team measures success by whether the infrastructure works
not by whether developers choose to use it.
This is engineering focus instead of product focus.
A product mindset starts with the user.
What problem are you solving?
For whom?
How will you know if you solved it?
Success is measured by adoption and satisfaction,
not by technical purity.
You make trade-offs.
Sometimes you accept architectural compromise
to reduce cognitive load.
You prioritize ease of use over elegant design.
You measure what matters to your customers, the developers,
not what is technically interesting.
The third failure mode is forcing adoption instead of earning it.
Some organizations mandate that developers use the platform.
New projects must use the golden paths
and teams can't deviate without approval.
This creates resentment.
The platform becomes something developers resent.
Instead of something they appreciate, they find workarounds.
They complain.
Adoption numbers look high because it is mandated,
but actual usage is low and grudging.
Adoption you earn is better than adoption you force.
When developers choose to use the platform
because it is genuinely easier than the alternative,
adoption is voluntary and sustainable.
This requires that the platform actually deliver value.
It requires that it solve real problems.
It requires that using it be easier than working around it.
If the platform is so good that developers choose it willingly,
you have a winning product.
If you need to force it, you have a problem
that mandates won't solve.
The fourth failure mode is ignoring developer feedback.
Platform teams release something
and don't listen to what developers say.
The friction points they mention.
The features they request, the alternatives they prefer.
Ignoring this feedback means you miss the signals
that the platform isn't solving the right problems.
Development teams quietly build alternatives.
They work around the platform.
They don't complain because complaining didn't help last time.
The platform becomes quietly irrelevant.
The fixes systematic feedback loops, surveys, interviews,
watching how developers work, building channels for input
and most importantly, acting on it.
If developers say something is confusing, fix it.
If they request a feature, evaluate whether to build it.
If they are finding workarounds, understand why
and address the gap.
Feedback should visibly influence platform direction.
When developers see that their feedback matters,
they engage with the platform team.
They invest in the process.
The fifth failure mode is ambiguous ownership.
When everyone is responsible for the platform,
it means nobody is responsible.
Decisions don't get made.
Feedback doesn't get processed.
Roadmaps don't get published.
The platform stagnates.
Clear ownership means a product manager
or a platform leader takes responsibility for success.
They own the roadmap.
They are accountable for adoption.
They measure outcomes.
They drive iteration.
Success requires product discipline
applied to an internal platform.
Not engineering discipline, product discipline,
built for users, measure adoption, listen to feedback,
iterate based on outcomes.
This is how platforms actually work at scale.
The strategic shift in operating model,
platform engineering isn't a tool change,
it isn't a debate about bicep versus terraform.
Or whether you should pick GitHub actions over Azure DevOps.
Those are tactical choices.
They come later.
The real shift is organizational.
It's about how your company actually makes decisions.
Who builds the systems, who maintains them,
who owns the responsibility and one level deeper.
It's about how you measure success and how careers advance.
This shift creates roles that simply didn't exist before.
Platform engineers are not just traditional infrastructure
engineers with a new title.
Infrastructure engineers manage systems.
They keep the lights on.
They react to failures.
Platform engineers design products.
They study how developers work.
They anticipate what's coming.
They build solutions and measure adoption.
It's the difference between operations
and product development.
Both are necessary, but the mindset is completely different.
We're also seeing product managers enter the engineering org
in a brand new context.
They aren't managing customer-facing apps.
They're managing the internal platform.
They own the roadmap.
They talk to developers to find out what actually matters.
And they make the hard trade-offs
between technical purity and ease of use.
They're accountable for adoption.
They're accountable for satisfaction.
They drive the organization to treat the platform
as a product, not just a pile of infrastructure.
Then you have developer advocates.
Their job is to find the friction.
They identify the gap between what the platform provides
and what the developers actually need to get their work done.
They evangelize, they gather feedback.
They help teams move to new capabilities.
They sit right in the middle.
They speak both languages.
These roles require different hiring criteria
and different performance metrics.
You aren't just looking for engineers who conscript
that you're looking for product people.
You're looking for people who care about adoption
and user happiness.
And you're building a product organization
inside your infrastructure function.
The metrics that matter change fundamentally.
Traditional infrastructure is about uptime.
Availability.
And how fast you respond to an incident.
Those still matter.
The platform has to be reliable.
But reliability is just table stakes.
It isn't the goal.
The goal is adoption.
How many teams are using the platform?
How many new services are moving through the golden paths?
How satisfied are your developers?
Those are product metrics.
Budget models shift to in the old model.
You have a fixed-ops budget.
You hire a set number of people to handle the load.
And if the load goes up, you hire more people.
In platform engineering, you invest upfront.
You spend the money to build golden paths
and self-service tools.
That investment is supposed to drive down
the cost of every future project.
You measure the ROI.
Did this work reduce the manual toil?
Did it free up the ops team to actually innovate?
The organizational structure flattens out.
Traditional models are rigid hierarchies,
with approvers and requesters, policymakers,
and rule followers in the platform model.
That distinction collapses.
Developers don't ask for infrastructure.
They self-serve.
Ops doesn't approve or deny.
They build the system that makes the approval automatic.
The interaction shifts from vertical to lateral.
The culture becomes one of continuous learning.
The platform is never done.
It needs to iterate based on what developers are actually doing.
This requires a culture where people experiment, get feedback,
and improve.
Failure is just learning.
You ship something.
You see what works.
You listen to what doesn't.
And then you fix it.
Career progression changes too.
In traditional ops, you move up by being the person
who makes the big decisions.
In platform engineering, you move up by enabling more work
by building things that teams choose to use,
by driving adoption.
Your value comes from multiplying what everyone else can do,
not from controlling what they do.
From bottleneck to enablement,
the old operating model moved the bottleneck
without ever actually fixing it.
You just change to was waiting.
The structural problem was always the same.
Infrastructure decisions required a human to say yes.
And whenever you need a human to say yes,
queues form, waiting increases.
Platform engineering eliminates that bottleneck,
not by hiring more people to say yes,
but by automating the yes itself,
by encoding those decisions into templates,
by making governance a part of the deployment,
not something you check afterward.
Golden paths, built with bicep modules,
make this possible at scale,
developers follow them because it's easier than doing it themselves.
They aren't forced, it's just better.
The shift from tickets to templates is structural.
You're changing how decisions get made,
from approval-based to automation-based,
from days to minutes.
This matters to executives because it hits the business outcomes
that count, faster delivery, better attention, lower risk.
This is how you move from being the bottleneck
to being the enablement.