It was 2010, a simple idea spread through the tech world.
You build it, you run it, that was the promise.
Eliminate the handoff.
No more tossing code over the wall to operations.
No more waiting weeks for infrastructure.
No more, that's not my job.
Developers and operators would merge.
They'd own the entire life cycle, responsibility,
autonomy, speed.
And for a moment it worked.
But by 2026, something broke, not the idea, the execution.
Today, developers aren't shipping faster.
They're drowning.
They're drowning in Kubernetes configurations.
They don't understand.
In YAML files, that never passed the same way twice.
In permission models, so complex that they've
stopped trying to understand them.
They're buried under compliance checklists
that land on their desks like avalanches.
They're stuck with observability tools
that require doctorates to configure and security scanning
that blocks deployments for reasons nobody can explain.
The DevOps promise didn't fail because the idea was wrong.
It failed because it scaled wrong.
And now, there's a cost nobody wants to measure.
A hidden tax that sits on every engineering budget.
A tax that compounds.
A tax that's invisible on the balance sheet,
but very visible in burnout, in turnover,
and in missed delivery dates.
This is the DevOps tax.
The DevOps tax defined.
The DevOps tax isn't a tool problem.
It's not about Jenkins being slow or Docker being hard.
It's about what happened when organizations took a good idea
and tried to scale it to thousands of engineers
without the infrastructure to support it.
The original intent was clean.
Break down the wall between development and operations.
Stop the blame shifting.
Stop the silos.
Make teams own what they build.
What actually happened was different.
Every developer became a part time infrastructure engineer.
And nobody asked them if they wanted the job.
Think about what a developer needs to understand now.
Not once needs.
They need to understand their cloud provider.
Maybe it's Azure, maybe AWS, maybe both.
They need to understand containers and how to build them.
Kubernetes, if they're not living under a rock.
Networking, RBAC, storage classes, persistent volumes,
ingress controllers, service meshes, CICD pipelines,
Git workflows, terraform or bicep,
depending on what your organization chose,
Prometheus or DATA Dog or New Relic, log aggregation,
distributed tracing, security scanning, compliance frameworks,
network policies, pod security policies, secrets management,
disaster recovery, cost optimization, the list never ends,
and none of that is the product they are supposed to be building.
The metric that should matter, the one nobody measures is this.
How much of your engineering team's capacity is actually spent
on business logic versus undifferentiated heavy lifting?
The answer is brutal.
Research shows 74% of developer capacity is consumed
by shadow operations and infrastructure toil
instead of shipping features.
74%, that's not an anomaly.
That's the baseline, that's the tax.
And it's called a tax for a reason.
Taxes are unavoidable, you can't opt out, they compound.
A 2% tax becomes 4% becomes 8%,
and they're invisible.
The infrastructure cost doesn't show up on the PNL.
It shows up as missed deadlines as junior engineers
who burned out after two years
and as senior architects who stopped mentoring
because they're too busy debugging Kubernetes networking.
The DevOps tax is the gap between what you pay for engineering
and what you actually get in business value.
It's the cost of giving every team the responsibility
to run production infrastructure
without giving them the tools to do it at scale.
It's the cost of tool proliferation without standardization.
It's the cost of pushing decisions down to the team level
without a framework to help them make good ones.
In small organizations, this tax is manageable.
A 5% team can all understand each other's infrastructure choices.
Context is shared, decision making is fast,
the cognitive load is spread across people
who already know the system.
Scale to 50 teams, 100 teams,
suddenly you're not managing infrastructure anymore,
you're managing chaos, and the chaos is extracting a price
you're not accounting for.
How DevOps broke at scale?
The model worked fine when teams were small,
but here's what changed.
Between 2010 and 2015, DevOps wasn't a failure,
it was a massive success story, small teams loved it.
A group of 15 engineers could own their entire stack
without any outside help.
They knew each other, they shared context.
When someone needed to deploy,
the person who built the feature
was the same person running it in production.
Responsibility was direct, feedback was immediate.
If something broke at midnight,
the engineer who actually wrote the code got the page
and fixed it because they owned the outcome.
In those early years,
the infrastructure was simple enough for developers to learn.
You learned Git, you learned a few bash scripts,
you understood a Docker file, the barrier to entry was real,
but it was surmountable for most people.
A competent developer could pick it up in weeks rather than months,
and once they did, they had total clarity,
they knew what they were responsible for,
they knew what could break, they knew how to fix it,
then organizations grew.
Five teams became 10, 10 became 50, 50 became 200,
and somewhere in that progression, the model broke,
not in theory, but in practice.
What actually happened is that the number of tools
didn't grow at a steady pace, it exploded.
Every time a new team joined,
they didn't just add more infrastructure decisions.
They added their own preferences,
their own choices, their own dependencies.
Team H.O.'s Jenkins for their CICD,
Team B thought Jenkins was outdated,
so they built everything on GitLab instead.
Team C found Jenkins too heavy and moved to GitHub actions
while Team D is still using Circle CI
because they never found a reason to switch.
Now you have four different systems running at once,
and nobody can explain why.
The same thing happened with observability,
one team uses Prometheus, another uses DataDog,
a third uses New Relic, a fourth team is still logging
to an Elk stack they've had for years
because nobody wants to deal with the migration.
A fifth just adopted Grafana Cloud.
Each choice was rational for that specific team
at that specific time, but collectively,
they created a mess of incompatibility.
Then you add container orchestration,
most teams use Kubernetes, but some use container instances,
and one team decided they didn't need containers at all
and went back to virtual machines.
Now the platform team has to support all three.
The ops team is constantly switching context.
The documentation is split, the runbook's diverge,
you add Terraform to one team,
bicep to another and cloud formation to a third.
You add PagerDuty, Slack, CustomWebhooks,
and automation scripts that nobody remembers writing.
You add security tools that work in some pipelines
but fail in others.
The result isn't a coherent platform.
It's a collection of semi-connected tools held together
by documentation that's always out of date
and institutional knowledge that lives
in the heads of three senior engineers.
That's where decision paralysis sets in.
When a new team forms, they can't just use the stack
because the stack doesn't exist.
They have too many options.
Do we use Kubernetes or container instances?
Terraform or bicep, Prometheus or DataDog?
Every choice branches into a dozen more sub-decisions
about resource limits, networking models,
and backup strategies.
A team that should be shipping features is spending
entire sprints just deciding how they'll run their infrastructure.
Meanwhile, the coordination tax explodes.
Teams aren't independent anymore.
They're interdependent.
Team A uses a database configuration that team B depends on
and team C's networking model conflicts
with what team D is trying to do.
Everyone attends meetings, everyone writes documentation,
everyone adds cross-team dependencies to their roadmaps
and the senior engineers, the architects.
The people who should be designing systems
are spending half their time debugging
why Kubernetes networking isn't working the way one team expects.
They're in meetings explaining why they can't change
a shared database configuration without three weeks of notice.
They're writing runbooks for corner cases
that nobody should have to understand.
The burnout isn't subtle.
It's structural.
The cognitive load crisis.
This is where it gets personal for your team.
Cognitive load is a theory from psychology
that describes the mental effort required to finish a task.
It has three layers.
The first is intrinsic load.
That's the inherent complexity of the problem you're solving
if you're building a payment system that's complex by nature.
You need to understand transactions, security, and audit trails.
That complexity is unavoidable.
It comes with the job.
The second is extraneous load.
That's the unnecessary complexity caused
by how you're solving the problem.
It's the friction that has nothing to do with the business logic.
It's the mental energy spent on tool choices,
process overhead, and documentation gaps.
Extraneous load is the tax.
The third is germane load.
That's the productive mental effort spent on learning and solving.
It's the thinking you actually want developers to do.
How should we structure this system?
What patents fit this domain?
The DevOps model, when it's scaled without guardrails,
maximise the tax and crushed the productive thinking.
A developer sitting down to build a new service
doesn't start by thinking about the product.
They start by thinking about infrastructure.
Do we use Kubernetes or container instances?
If Kubernetes, what networking model, service mesh, or not,
how do we handle secrets?
What's the disaster recovery strategy?
What resource limits should we set?
15 to 20 distinct concepts.
Every single one of them is necessary.
None of them are optional.
And that's before they write a single line of business logic.
A junior engineer spends weeks just trying
to understand the landscape.
A senior engineer navigates it faster,
but the cognitive tax is still there.
Their brain is constantly switching
between infrastructure concerns and product concerns.
That switch has a cost.
Every context switch drains mental energy.
Every decision that isn't about the product adds fatigue.
The research community calls this concepts to ship or CTS.
It's the count of distinct things a developer must understand
just to get a service into production.
For a manually configured DevOps environment,
CTS usually runs between 15 and 20.
You have Kubernetes networking,
RBAC permissions and storage classes.
You have ingress controllers, config maps, and resource
limits.
You have network policies, observability setup,
and CI/CD pipeline configuration.
Each concept requires study, each requires decisions,
each adds friction.
A mature platform reduces that count to four or five.
Service name, environment, replica count, resource limits.
The difference between four and 20 isn't just mental.
It's organizational.
A developer working in a four-concept system
can focus 80% of their energy on the product.
A developer working in a 20-concept system
has it backwards.
Infrastructure becomes the problem.
The product is just what they do in the gaps.
And organizations don't measure this.
They measure how often they deploy.
They measure uptime.
They measure cost.
But they don't measure cognitive load.
They don't ask how much of your mental capacity
is spent on infrastructure instead of the product.
If they did, they'd see the tax clearly.
They'd see that the brilliant architect
who should be designing the next generation of systems
is instead debugging R-back permissions.
They'd see the team lead who should be mentoring is,
instead explaining why a Kubernetes manifest won't apply.
They'd see the junior engineer who should be learning
clean code is instead copy-pasting YAML from stack overflow
without understanding what it does.
The devil's promise was supposed to eliminate waste.
Instead, it created a new kind of waste, not operational waste,
cognitive waste.
And that waste is compounding.
Why manual configuration doesn't scale?
The model breaks the moment you look at how
infrastructure actually gets built.
In organizations that never moved past manual configuration,
the process is a mess.
A team needs a database.
They open the Azure portal.
They write a random script.
Or they follow a runbook written three years ago
that's probably missing half the steps.
They provision the instance, set some parameters,
add firewall rules, and create credentials.
The database exists.
It works.
It's in production.
But here's the problem.
This team's database looks nothing
like any other team's database.
Team A uses one SKU.
Team B uses another.
The backup policies are different.
The networking models are different.
One team uses a public endpoint with IP restrictions,
while another uses private endpoints.
And a third uses service endpoints.
Technically, they all work.
They all store data.
But they aren't consistent.
Consistency sounds like a nice to have feature.
In reality, it's the only way an organization can scale.
When you have five teams, inconsistencies, just friction.
You document the right way to do it.
Most teams follow it.
Some don't.
Some want grumbles in a meeting about why they aren't
any mandates.
And then everyone moves on.
But when you have 50 teams, inconsistency becomes chaos.
Your runbooks break because they assume
a specific setup that doesn't exist.
Your monitoring breaks because every team
use different alert thresholds.
Your backups are a gamble because retention policies vary
from person to person.
Your disaster recovery tests fail
because the replication settings weren't standardized.
The knowledge of how things should actually work lives
entirely in the heads of individual engineers.
And that leads to the next problem, knowledge hoarding.
Senior engineers become the only people
who understand the right way to build.
They've seen the patterns.
They know the gotchas.
They know why a specific parameter has to be set
to a specific value.
And they become the bottleneck.
A junior engineer can't provision infrastructure
with any confidence.
They have to ask.
They have to wait for the one person who knows.
But that person is busy.
They're always busy.
So the junior engineer either waits, or they guess,
or they copy what another team did, even if it's wrong.
The senior engineer ends up reviewing every single move.
They become a gatekeeper.
Their calendar fills up with approvals and reviews.
They have less time to solve actual architectural problems.
And more time managing a consistency crisis
they created by never writing down the rules.
Governance becomes theoretical.
Your security team writes down policies.
All databases must have encryption.
All databases must have backups.
All databases must be in private subnets.
These are official.
They're also meaningless.
Because there is no way to enforce them.
Instead, enforcement happens through code review.
Someone opens a pull request.
Someone else reviews it.
If they remember the policies, they might catch a mistake.
If they're busy, they'll miss it.
The engineer might argue they have a good reason to break the rules.
The reviewer might believe them, or they might not.
The result isn't a system that prevents errors.
It's two people spending an hour arguing
about whether an error is acceptable.
That's not governance.
That's theatre.
Audits become post-mortems instead of actual validation
once a year.
Auditors show up.
They ask for the disaster recovery plan.
You scramble to test it only to find out
your backups haven't worked for six months.
You fix it.
And then you do the same thing next year.
And this is where things change.
Because now we're adding AI to the mix.
M365Copilot is powerful.
It can summarize documents, write code, and automate workflows.
It can also interact with your infrastructure.
It can read your configurations.
And here's the shift.
When copilot interacts with manually configured infrastructure,
it inherits every inconsistency and every shortcut you ever took.
If you tell copilot to provision a database,
and it doesn't have a golden path to follow,
it makes decisions based on what it sees.
And what it sees is chaos.
Some databases are encrypted, some aren't, some have backups.
Some don't.
Copilot might copy a patent from a legacy system
that was built wrong ten years ago and never fixed.
Now you don't just have inconsistent infrastructure
managed by humans.
You have inconsistent infrastructure managed by humans
and amplified by AI, making decisions at a scale
you can't easily reverse.
Manual configuration stops working the moment you add intelligence
to the system.
The real cost of shadow it.
Here's what happens next.
And this is inevitable.
The official path is too slow.
It requires approvals.
It requires documentation.
It requires following a process that doesn't make sense.
So teams don't follow it.
Instead, they build their own.
They provision infrastructure using scripts
in a random repo nobody knows about.
They automate workflows using cloud accounts only they can access.
They build platforms inside your platforms.
They create notification systems
that don't talk to the official ones.
They stand up databases in unapproved regions
because the approved ones were too slow.
They bypass your CICD because it's easier to just deploy
directly.
This is shadow ET and it's not rogue behavior.
It's not in subordination.
It's a rational response to a broken system.
When the official path has high friction,
teams don't sit around waiting.
If a database takes two weeks and three approvals,
they'll find a way to do it in 10 minutes.
They solve the problem themselves.
From their perspective, this makes sense.
They ship faster.
They get their work done.
But from an organizational perspective,
you've just lost control.
The hidden costs pile up in places you can't even measure.
First, duplicated effort.
You have a platform team building standard patterns.
But you also have 15 other teams building their own versions
of those same patterns.
That's not two versions.
It's 20.
Every team reinvented the wheel.
Every team spent engineering hours building something
that already existed.
But they didn't know it because the official option was too slow.
Second, security gaps.
Your security policies are supposed to apply to everything.
But when infrastructure is built outside your framework,
the policies don't exist.
An engineer spins up a database with public access
because they didn't know any better.
A team configures storage with world readable permissions
because it was easier than figuring out your R-back model.
A service runs without encryption
because the engineer didn't realize it was mandatory.
These aren't malicious acts.
Their gaps created by a lack of guardrails.
Third, compliance violations.
Auditors want to see every piece of infrastructure in production.
You can show them the official systems.
But you can't show them the rest
because you don't know the rest exists.
An engineer deployed something two years ago
and left the company.
The service is still running.
Nobody knows who owns it.
Nobody knows if it's compliant.
You have massive risk.
And you don't even know where it is.
Fourth, knowledge silos.
The person who built the shadow system
is the only one who understands it when they leave.
That knowledge is gone a year later.
The system breaks.
Nobody can fix it because nobody knows how it works.
You're paying to maintain infrastructure.
You didn't even know you had.
The metric that captures this is the escape rate.
How often do teams bypass the official platform entirely?
Research shows that if your escape rate is above 20%,
it's a warning sign.
If it's above 30%, you've lost control.
If it's above 50%, you don't have a platform.
You have a suggestion.
Most organizations don't measure this
because they're afraid of the answer.
When they finally do, they often find
that 40% of their infrastructure is running
outside the official framework.
40%.
That's not a technical issue.
It's a governance failure.
The risk just keeps compounding.
You lose visibility into production.
You can't forecast costs because you don't know what's out there.
You can't manage security because you aren't
seeing the whole picture.
You're flying blind.
And the security risk is immediate.
Shadow infrastructure is almost never monitored.
Backups don't run.
Disaster recovery isn't tested when something breaks.
There's no documentation when someone attacks it.
Nobody notices for months.
This is the real cost of a platform
that isn't good enough to actually use.
DevOps versus platform engineering, the shift.
The failure is obvious now.
The model breaks.
Teams can't navigate the complexity
so they create their own solutions.
The platform doesn't contain them.
It fragments them.
So what changes?
This is the critical move.
It isn't a technology shift.
It's a philosophical one.
DevOps said, distribute responsibility to the edges.
Make teams own their own infrastructure.
The logic was sound, eliminate handoffs, eliminate silos,
make people accountable for what they build.
Platform engineering says something different.
Centralize capability at the foundation.
Make teams own their products, not their infrastructure.
This sounds subtle.
It's not.
DevOps distributes the burden.
Everyone gets the power to configure everything.
And everyone gets the responsibility to understand it.
That's the deal.
You want autonomy, you get complexity, you want ownership,
you own all of it.
Platform engineering inverts the trade off.
It says, you get autonomy over what matters, your product,
and the platform owns what doesn't.
You own your features, you own your business logic,
you own your user experience.
The platform owns how your code gets deployed,
the platform owns how your service gets monitored,
the platform owns how your access is managed,
the platform owns how your infrastructure gets secured.
The difference isn't theoretical.
It's structural.
In a DevOps organization, a team that needs a database
has to understand databases.
They have to understand backup strategies,
replication, scaling, failover, and disaster recovery.
Because they have to make decisions about all of it,
they own the consequences when things go wrong.
In a platform engineering organization,
a team that needs a database, submits a request.
The platform provisions it.
It's pre-configured with industry standard backup strategies,
replication, scaling rules, and failover logic.
The team doesn't need to understand any of it.
They just use it.
The DevOps team is responsible for learning.
The platform engineering team is responsible for deciding.
This shift changes what teams look like.
In DevOps, you have a large central ops team
managing shared infrastructure
and large distributed teams managing their own infrastructure.
In platform engineering, you have a small dedicated platform team,
your infrastructure as product and product teams that consume it.
The platform team doesn't manage infrastructure.
They don't run servers.
They don't fight fires.
They build systems that let other teams run their own infrastructure
without having to understand all of it.
This is the key inside.
Infrastructure as a product.
A product has a user experience.
It has documentation.
It has an API.
It has support.
It has a roadmap.
It has a team that cares whether people actually use it.
When someone doesn't understand how to use the product,
the product team doesn't blame the user.
They blame themselves.
The product wasn't clear.
The documentation wasn't helpful.
The feature didn't match the use case.
Platform teams operate the same way.
If teams aren't using the platform,
it's not because the teams are incompetent.
It's because the platform isn't solving their problem.
The interaction model is completely different.
In DevOps, the interaction is collaboration.
Teams coordinate.
They align.
They negotiate.
They submit tickets.
They wait for approvals.
There's constant back and forth
because the boundary between responsibility isn't clear.
In platform engineering, the interaction is X as a service.
X as a service means here's a service.
Here's how you use it.
Here's what it does.
You don't need to talk to us.
You don't need our permission.
You don't need to coordinate.
You request a resource.
The system provisions it.
It's available in minutes.
It's documented.
It works.
This enables the outcome that matters.
In a DevOps organization,
developers spend 20% of their time on business logic
and 80% on infrastructure.
They're drowning.
They're context switching.
They're making infrastructure decisions
that have nothing to do with the product.
In a platform engineering organization,
developers flip that ratio.
They spend 80% of their time on business logic
and 20% on infrastructure.
The platform handles the undifferentiated heavy lifting.
Developers focus on what differentiates their product.
That's not just a productivity improvement.
That's a structural change in what becomes possible.
An engineer who spends 80% of her time on the product
can think clearly about architecture.
She can mentor junior engineers.
She can design for scale.
She can reason about trade-offs.
An engineer who spends 80% of her time managing infrastructure
is in triage mode.
She's reactive.
She's solving firefights.
She's not building.
The shift from DevOps to platform engineering
is the shift from distributed burden
to centralized responsibility.
It's the shift from everyone learns infrastructure
to everyone uses infrastructure well.
It's the shift from infrastructure
as a cost to infrastructure as a product.
And that shift has to start somewhere.
What golden paths actually are?
The philosophy is clean.
The execution is the hard part.
How do you actually move from the old model to this new one?
You start by building what the platform team calls a golden path.
This term gets thrown around a lot.
So let's be precise about what it means.
A golden path is an opinionated pre-built workflow
that handles the 80% of use cases that are actually common,
not all use cases, not every possible variation.
The 80% that show up repeatedly across your organization.
What does it include?
Infrastructure templates.
You have a service.
It needs to run somewhere.
The golden path says, here's how we run services.
Here's the standard compute configuration.
Here's the network setup.
Here's the storage.
Here's the secrets management.
Here are the security baselines that are already configured.
You don't choose them.
They're the default.
It includes CI/CD pipelines.
Not blank slate pipelines where teams decide
how to build and deploy.
Standard pipelines.
Your code gets built this way.
Your tests run with these tools.
Your deployment follows this process.
Security scanning happens here.
Compliance checks happen there.
It's all automated.
It's all consistent.
It includes observability, setup, logging, metrics,
tracing, alerts, already wired, already pointing
to the right systems.
A service that follows the golden path is automatically
observable.
You don't have to remember to add instrumentation.
You don't have to figure out which monitoring tool
the org standardized on.
It's already there.
It includes compliance checks.
Your service is automatically validated
against policy when it deploys.
No compliance team reviewing it later.
No security team doing a post-deploy audit.
The policy is embedded in the path.
Your deployment either meets the requirements
or it doesn't deploy.
But the golden path does not include
is escape hatches.
It doesn't say here's the standard way,
but if you need something different,
follow these 30 other procedures.
That's not a golden path.
That's a maze with a recommended route.
The golden path is the route.
If you're on it, you're good.
If you're not, you need to talk to someone.
This is intentional.
The escape hatches are collaboration moments.
The golden path handles 80%.
The other 20% requires actual conversation
with the platform team.
Maybe you have a legitimate edge case.
Maybe your domain requires a different architecture.
That's fine.
But you can't do it quietly.
You can't do it by following some hidden alternative procedure.
You have to have a conversation.
The platform team needs to understand
why the golden path doesn't work for you.
They might refine it.
They might approve an exception.
But they'll know about it.
The design principle underlying all of this is simple.
Make the default choice the best choice for most teams.
In a manual environment, the default is figure it out yourself.
The best choice is whatever works, but you have to discover it.
There's no default.
There's no best practice embedded in the system.
You explore, you experiment, you find something that works,
or you copy what another team did.
In a golden path environment, the default is the best choice.
You don't explore because exploration is expensive.
You don't experiment because experimentation
creates variance.
You don't copy because there's nothing else to copy.
You follow the path.
And the path is designed to work.
What does using a golden path look like from a user perspective?
It looks simple.
You fill out a form or you run a CLI command or you use a portal.
The form says, what's your service name, what environment,
how many replicas do you need?
Maybe how much memory and CPU?
That's it.
Five fields instead of 50, you submit.
A few minutes later, your service exists.
It has a CI/CD pipeline.
It has monitoring.
It has security scanning.
It has compliance checks.
It has alerts.
It has everything.
You don't read documentation.
You don't make 30 decisions.
You don't learn 15 new concepts.
You just describe what you want and the system builds it.
This is how you reduce CTS, not by teaching people more concepts,
by making the concepts irrelevant.
The platform handles them.
You don't need to understand them.
The measurement that matters is adoption.
What percentage of new services use the golden path?
And how fast do services go live?
If adoption is below 70%,
your golden path isn't good enough.
If time to first deploy is still measured in weeks instead of hours,
you haven't actually solved the problem.
The metrics tell you whether the path is actually working.
Infrastructure as code as the foundation,
you can define a golden path.
You can build beautiful documentation.
You can even create the best form in the world
for teams to request infrastructure.
But none of it matters if you can't actually deliver
what you promised at scale.
And you can't deliver at scale without infrastructure as code.
ISE is straightforward in concept.
It means expressing your infrastructure as version controlled code.
Instead of clicking buttons in the Cloud Console,
you write files, bicep files, terraform files, or CloudFormation templates.
These files describe exactly what you want to exist.
You commit them to Git.
You review them like you review application code.
You deploy them through pipelines.
They are auditable, reproducible, and trackable.
The word reproducible is doing a lot of work here.
It means if someone asks if you can stand up
an identical copy of a service in another region,
the answer is yes.
You don't rely on someone's memory of which buttons
to click or what settings to choose.
You run the same code.
You get the same result every single time.
Auditability means you can see exactly what changed when it changed
and who made the change.
It is all in Git.
If a security team needs to know what firewall rules were added
three months ago, they look at the Git history.
They see the PR, they see the approval, they see the deployment.
There is no mystery.
There is no, I think we added something, but nobody documented it.
The infrastructure is documented by its own code.
But the real power is enforcement.
When infrastructure is manual, governance is a suggestion.
You write a policy.
You hope people follow it.
When infrastructure is code, governance is a barrier.
Policies become automated checks.
They run on every deployment.
If your infrastructure violates a policy,
the deployment doesn't proceed.
You didn't have to think about compliance
because the system enforced it for you.
You can't deploy an unencrypted database
because the policy won't let you.
You can't create a public IP address
because the policy blocks it.
You can't open a firewall rule to all traffic
because the system won't allow it.
This is the governance layer.
It isn't a gate that blocks after the fact.
It is a guardrail that prevents the wrong action in the first place.
So the question becomes, which tool do you use?
Bicep and Terraform are the two serious choices
for Azure organizations.
Bicep is Microsoft's language.
It compiles to arm templates.
It is native to Azure.
When Microsoft releases a new Azure service,
bicep supports it immediately.
There is no wait, no provider lag,
and no waiting for a third party provider to catch up.
bicep integrates tightly with Azure policy.
You can express governance rules in the same language
as your infrastructure.
Everything feels connected because it is all built on the same platform.
Terraform is agnostic.
It works on Azure, AWS, GCP and dozens of other platforms.
This is powerful if you are multi-cloud.
One language, one workflow.
Consistent across your entire infrastructure portfolio.
But the trade-off is that Terraform relies on provider plugins.
Those plugins are maintained by the community.
When Azure releases a new service,
someone has to build support for it in the Terraform provider.
That takes time.
Sometimes weeks, sometimes months.
You are always slightly behind.
For a pure Azure organization, bicep wins on native integration.
For a multi-cloud organization, Terraform wins on consistency.
The choice depends on your strategy.
But either way, you need the ISE life cycle.
You author the code, you push it to a branch, appear, reviews it.
They make sure it follows your patterns.
They verify the policy implications.
They approve or suggest changes.
The code is deployed to a non-production environment.
It runs there. You verify it works.
It goes to production, but first in audit mode, the policy runs.
It logs what it would enforce.
You verify nothing breaks.
Now the policy actually blocks violations.
It is live. It is protecting your infrastructure.
This life cycle takes infrastructure from a reactive problem to a proactive system.
Violations aren't discovered in audits.
They are prevented at deployment time.
And here is what matters.
Infrastructure changes become as traceable,
reviewable, and roll backable as application code.
If something goes wrong, you don't just know about it.
You know exactly what changed.
You can revert.
You can see who made the change and why.
You have a complete audit trail.
This is what makes large-scale infrastructure governance possible.
Not policies written in documents, not reviews done manually.
Code that enforces itself.
Policy as code.
Embedding governance.
Infrastructure as code is the foundation.
But code alone isn't enough.
Code is just text. It describes what you want.
It doesn't prevent what you don't want.
That's where policy as code comes in.
Policy as code is the practice of expressing your governance rules
as code that runs automatically during deployment.
Security requirements, compliance rules, cost controls, architectural standards.
It isn't a checklist that someone reviews manually.
It isn't a policy document that people are supposed to read.
It is code that runs, evaluates your infrastructure, and makes a decision.
This is allowed, or this is not.
The distinction matters because everything changes when governance becomes automatic.
When your security policy says, all databases must be encrypted.
That is a policy.
When you express it as code that blocks the deployment of any unencrypted database
that is policy as code, one is advisory.
The other is a guardrail.
Azure policy is the native tool for this.
You define a policy.
It is a set of rules that evaluate resource configurations.
Does this database have encryption enabled?
Is this storage account using secure transfer only?
Is this network security group exposing this port to the internet?
The policy is the question.
The enforcement is the answer.
Then you assign that policy to a scope,
usually a management group or a subscription.
Once assigned, every resource created within that scope
is evaluated against the policy.
Automatically, without human review,
the enforcement model is crucial.
You can run a policy in audit mode.
It evaluates your infrastructure and logs violations,
but it doesn't block anything.
This is how you test.
You see what would break.
You give teams time to adjust.
Then you flip it to deny mode.
Now, the policy actually blocks deployments that violate it.
This is the inverse of the manual approach.
In manual governance, you hope people follow the rules.
In policy-driven governance, the rules are enforced by the system.
Here is what changes for a developer.
They don't need to know the security policy.
They don't need to understand compliance requirements.
They follow the golden path.
The golden path is pre-configured with all the policy guardrails
already baked in when they deploy the policy's run.
They are already compliant because the path ensures it.
The developer experience is simple.
They provision a database through the platform.
The system provisions it.
It is encrypted.
It has backups.
It has the right access controls.
It meets every policy.
Not because the developer made those decisions,
but because the system made them
and the policy validated them.
This is where governance stops being a burden
and becomes a platform capability.
Measurement shifts, too.
Instead of asking if you are compliant after an audit,
you ask for your real-time compliance score.
This is the percentage of resources that meet policy.
If it is 95%, you are in good shape.
If it is 70%, you have violations that need attention.
And you know exactly which resources violate which policies
because it is all tracked.
Time to compliance becomes a metric.
When a violation is discovered, how long until it is fixed?
In a manual system, this could be weeks.
Someone notices the violation.
Someone files a ticket.
Someone reviews it.
Someone fixes it.
The cycle is slow.
In a policy-driven system,
the owner gets notified immediately.
The violation is logged.
The owner fixes it.
The metric is days, not weeks.
The real outcome is a shift in responsibility.
Compliance stops being something
the security team enforces on everyone else.
It becomes something the platform enforces for everyone.
Security teams move from gatekeepers to architects.
They design policies that are sensible and enforceable.
They test them, they roll them out.
Then the system does the work.
No manual review, no compliance theater,
just automatic continuous validation.
This is how you scale governance,
not by hiring more security reviewers,
by making security automatic,
not by writing stricter policies,
by embedding policies into the systems
where violations are impossible.
When a developer can't create something insecure
because the policy won't allow it,
compliance isn't a negotiation.
It is a fact.
Team topologies, organizing for platform success.
Structure is everything.
You can build the best golden path in the world
and you can have perfect IAC and policy automation,
but none of it works if your organization is structured wrong.
And most organizations are structured wrong for this model.
The framework that fixes this is called team topologies.
It's a way of thinking about how teams should be organized,
not based on technical function,
but based on how cognitive load flows through the organization.
Team topologies defines four team types.
You've probably heard of streamlined teams and platform teams.
Those are the core.
But the full picture requires all four.
Stream aligned teams are product teams.
They own a complete value stream from end to end.
They own the features, they own the deployment,
they own the monitoring, they own the decisions,
they're not waiting on another team to move infrastructure
or approve deployments or explain how something works.
They own it.
This is the DevOps principle,
but applied to products, not to infrastructure.
Platform teams are the inverse.
They don't own products.
They own the capabilities that products consume.
They own the golden path.
They own the infrastructure automation.
They own the policy enforcement.
They own the CI/CD system.
They own the observability platform.
They're the infrastructure as product.
Every stream aligned team is their customer.
Then there are enabling teams.
These are temporary expert teams.
A cloud enablement team.
A security team that helps other teams adopt security practices.
An SRE team that coaches on observability.
These teams don't own anything permanently.
They own capability transfer.
They come in, help a stream aligned team learn a new practice,
embed that practice into the platform teams offerings,
and move on.
The fourth type is complicated subsystem teams.
These are teams that own a piece of infrastructure
that's so technically complex that it needs dedicated experts.
Maybe it's your Kubernetes cluster.
Maybe it's your database replication layer.
Maybe it's your distributed cache.
These teams exist to handle complexity that's better managed
by specialists than spread across the product teams.
Now, the interaction modes.
This is where it gets practical.
Collaboration is when two teams work closely together.
Lots of back and forth, shared goals,
figuring things out together.
This is appropriate during discovery.
When the platform team and a stream aligned team
are designing a new capability together, they collaborate.
When an enabling team is coaching a product team,
they collaborate.
But collaboration is exhausting.
It requires constant synchronization.
It doesn't scale.
X as a service is the steady state.
One team provides something.
Other teams consume it.
The interaction is through an interface, not through conversation.
The platform team provides a database service.
Stream aligned teams use it.
No collaboration.
No meetings.
You request a database.
The platform provisions it.
Done facilitation is the enabling team mode.
It's coaching, not management, temporary pairing.
Teaching, not doing.
An enabling team helps a product team adopt a new practice.
Once the practice is embedded in the platform,
once it becomes part of the golden path,
the enabling work is done.
The practice is now X as a service.
The cognitive load principle underlying all of this
is crucial.
Team boundaries aren't drawn to maximize technical elegance.
They're drawn to minimize the mental burden on every team.
A stream aligned team shouldn't have to understand
distributed systems, cloud cost optimization,
policy design, and compliance requirements.
That's too much cognitive load.
The platform takes those concerns off the table.
Now, the stream aligned team can focus on features.
A platform team shouldn't be forced into supporting
50 different infrastructure variations.
That's cognitive overload for them too,
but they standardize.
They build for the 80% case,
the rare exceptions go through collaboration mode,
but those are genuine exceptions, not the default.
An enabling team shouldn't be permanent.
They don't scale that way.
The moment an enabling team has to support everything permanently,
they become a bottleneck.
They're supposed to transfer capability, then shift focus.
This organizational model is what makes everything else work.
ISE and policy and golden paths are tools.
Team topologies is the structure that determines
how those tools actually function at scale.
Without this structure, you have platform chaos.
With it, you have clarity.
Stream aligned teams move fast.
Platform teams maintain standards,
enabling team spread capability.
And everyone has clear boundaries around
what they're responsible for understanding
that clarity is worth more than any tool.
The platform product mindset.
Here's where the real shift happens.
Because organizational structure alone
doesn't guarantee success.
You can have the right teams in place
and still build a platform nobody uses.
The difference between a platform that thrives
and the platform that becomes overhead is mindset.
Traditional infrastructure thinking treats the platform
as invisible infrastructure.
It should exist.
It should work.
It shouldn't demand attention.
You measure it on uptime and cost.
If it's running and it's affordable, success.
Product thinking is different.
The platform isn't infrastructure.
It's a product.
It has customers, in this case, developers.
And like any product, it's success.
Depends on whether those customers actually want to use it.
This distinction sounds academic.
It's not.
It changes everything about how you operate.
A product has a road map.
Not a backlog of technical debt
that accumulates until you're forced to address it.
A road map, a direction, planned improvements,
things you're removing, things you're adding,
and the road map is driven by what your customers need,
not by what your engineers think is cool.
A product has user research.
You don't guess what developers want.
You ask them.
You watch how they use the platform.
You pay attention to where they get stuck.
You notice the patterns in the requests they make.
You run surveys, you conduct interviews,
you understand the friction points,
a product has feedback loops.
When a developer struggles with the platform,
that's not a personal failure.
That's a product failure.
The platform didn't meet their needs.
The documentation wasn't clear enough.
The workflow was too complicated.
The feature didn't do what they expected.
You treat feedback as a gift, not as criticism.
A product has deprecation policies.
Nothing is forever.
Sometimes a feature was the right answer when you built it,
but circumstances change.
You don't leave it in place forever just because it exists.
You announce when something is ending.
You give teams time to migrate.
You provide clear guidance on what replaces it.
You do this in the same structured way
that a commercial product would.
A product has SLAs.
You commit to availability.
You commit to response times.
You commit to performance.
If you fail to deliver, you know about it and you fix it.
This matters because your customers depend on you.
If your CI/CD platform is down,
every developer is blocked.
That's not an inconvenience.
That's a business impact.
Now here's the crucial insight.
Adoption is the only metric that actually matters.
If teams aren't using your platform,
it's not because they're incompetent.
It's not because they're lazy or stubborn.
It's because the platform isn't solving their problem well enough.
Maybe it's slower than their work around.
Maybe the documentation is confusing.
Maybe the feature they need isn't there.
Maybe they tried it once.
It didn't work and they gave up.
The reason doesn't matter.
The fact is they chose something else.
When you measure adoption,
you get immediate feedback
on whether your product is actually working.
Adoption isn't aspirational.
It's the ground truth.
Either teams use it or they don't.
This drives the metrics that matter.
Net promoter score for the platform.
Would developers recommend it to their peers?
How many teams are using the golden parts
versus rolling their own?
How fast can a new service go live?
What percentage of infrastructure requests
are self-service versus tickets?
These numbers tell you whether the product is good.
When adoption is high,
your platform is solving a real problem.
When adoption is low, your platform has work to do.
No excuse is no blame, just data.
And data drives the roadmap.
This is how platforms stop being overhead
and become enablement.
When you design for users instead of for technical perfection,
adoption follows.
When you measure adoption and make it the success metric,
everything else aligns.
Every decision gets evaluated through one lens.
Does this help developers move faster?
That lens changes the organization.
Self-service as the default.
The product mindset changes how your platform operates,
but it only works if there is actual infrastructure behind it,
shifting from thinking like a product
to actually being one means removing friction.
You have to stop developers from reaching for something else.
Self-service is the mechanism.
It is the difference between a platform that enables
and one that constrains true self-service
means developers do what they need without asking for permission.
They provision an environment, they create a database,
they set up a CI/CD pipeline, they configure monitoring.
All without filing a ticket, all without waiting for approval,
all without having a conversation with the platform team.
This sounds dangerous.
You might think this leads to chaos or security gaps,
but the answer is no.
It only works if you design it correctly.
The friction points are usually very specific.
You see forms that demand 30 fields
when the developer only needs five.
You find documentation that contradicts itself
or assumes knowledge they don't have.
Then there are the approval workflows.
You submit a request and wait three days
for someone to decide if you are allowed to do something obvious.
The design principle is simple.
If a developer has to ask for help to use the platform,
you have failed. I am not talking about edge cases.
I am talking about the normal path.
If the standard thing a developer wants to do
requires human intervention, your platform is a bottleneck.
The actual mechanics are straightforward,
a developer opens a form, service name, environment,
resource limits.
That is it.
No cloud credentials, no role definitions,
no network configuration, no infrastructure decisions.
All of that is handled by the platform.
They submit a pipeline runs, the infrastructure is created.
10 minutes later, it is ready.
This works because the platform has already made the hard decisions.
The form does not ask which SKU they want for the database
because the platform already decided.
It provides the right size for 90% of use cases
if they need something different.
That is a conversation.
It is not the default path.
The guardrails are the key.
Self-service does not mean uncontrolled.
It means controlled by policy and not by process.
A policy is code.
It runs automatically.
It blocks the wrong action before it happens.
A developer can provision anything,
but they cannot provision something in secure
because the policy will not allow it.
They can create a database, but not one without encryption.
They can create a network, but not one that exposes the internet.
This is controlled without permission asking.
The developer does not feel controlled
because they are not waiting.
They are not jumping through hoops.
They provision what they need.
It works and it is compliant.
The policy runs silently in the background.
The metrics that prove this is working are simple.
The self-service ratio is the percentage of actions
completed without tickets.
If you are above 85%, you are winning.
If you are below 50%, your platform has friction
that is driving people away, then there is time to provision.
This is the time from I need a database
to my database is ready.
For a mature platform, this is measured in minutes.
For a broken platform, this is measured in days.
The metric exposes the truth immediately.
The outcome is a platform that disappears.
Developers use it without thinking about it.
They get what they need.
It is secure.
It is there.
They move on.
They are not building shadow systems
because the official platform actually works.
This is where safety and speed become the same thing.
They are no longer opposing forces.
A policy-driven platform is faster because there is no wait time.
It is safer because policies are consistent and automated.
You do not sacrifice one for the other.
The platform gives you both.
The measurement problem.
You cannot improve what you do not measure.
This is true for everything in engineering
and it is especially true for platforms.
Where the value is invisible, if you do not look for it.
Here is the baseline.
Most organizations measure platform success on two metrics.
Uptime, cost.
Is it running?
Is it affordable?
If the answer is yes.
They consider it a win.
This is lazy measurement.
It tells you if the infrastructure exists.
It tells you nothing about whether the platform is actually helping.
The standard for delivery performance is Dora.
Deployment frequency, lead time for changes,
change failure rate, time to restore.
These four metrics correlate with how an organization performs.
Teams that deploy frequently with low failure rates
are the high performers.
This is well researched and documented,
but Dora alone does not tell you if your platform is working.
Dora tells you if you are shipping fast.
It does not tell you if developers are happy.
It does not tell you if the platform reduced cognitive load.
It does not tell you if teams are using it or bypassing it.
This is why platform teams need to measure more.
Developer satisfaction is the starting point.
You need a net promoter score for the platform.
You ask one simple question.
Would you recommend this to a colleague?
The answer tells you immediately if you are winning.
Then look at the adoption rate.
What percentage of teams are using the golden parts
versus rolling their own?
If adoption is low, your product has work to do.
Look at time to first deploy.
This is the time from when a developer joins the company
to when they ship their first change.
This is a proxy for cognitive load.
A long time to first deploy means high friction.
Then there is the self-service ratio.
What percentage of requests are completed without tickets?
Low self-service means your automation is not good enough.
There is also cognitive load itself.
Remember the concepts to ship metric.
This is the number of distinct things
a developer must understand just to deploy.
But your platforms drive this down to four or five.
Manual DevOps environments require 15 to 20.
Measuring this tells you if you are reducing the burden.
Or just moving it around.
Here's the paradox.
30% of platform teams measure nothing at all.
Zero metrics.
They build a platform.
But they have no idea if it is working.
Another 40% cannot show ROI within 12 months of launch.
Think about that.
You invest six months building a platform.
You launch it.
And after a year, you still cannot prove it created value.
That is not a platform problem.
That is a measurement problem.
The organizations that do measure are the ones
that can tell a story.
A year ago, our average time to first deploy was three weeks.
Today it is four hours.
A year ago, developers spend 70% of their time on toil.
Today it is 20%.
Our adoption rate went from 40% to 85%.
Our deployment frequency doubled.
Our change failure rate dropped from 15% to 5%.
That is evidence.
That is proof.
The ROI calculation is where this becomes business critical.
A mature platform reports 200 to 800% ROI within 18 to 24 months.
If you invest $1 million, you are recovering 2 to 8 million
in value over two years.
But you only see this number if you measure it.
Without measurement, there is no ROI story.
There is just an expense that you are not sure justified itself.
Measurement also changes how the platform evolves.
Instead of guessing what teams need, you see where they are
struggling, you see where they get stuck, you see which
features are unused.
Measurement data becomes the roadmap, not politics, not
the loudest voice data.
The organizations that win treat the platform like a product
and measurement like science, they baseline everything
before they start, then they track relentlessly.
They are just based on data.
They prove value continuously.
And they use that proof to justify the next step.
Why most platforms fail?
Most platforms fail, not all of them, but most.
And the interesting thing is that these failures almost never
happen for technical reasons.
The technology is usually fine.
Your infrastructure as code works, your policy automation works,
the tooling itself is solid.
The platform fails because of organizational decisions
and operational choices.
Understanding these failure modes is actually more valuable
than understanding the theory, because you can design
the perfect architecture and still build something
that nobody ever uses.
The first failure mode is label theater.
This is where an organization renames a team
without changing a single thing about how it operates.
The DevOps team becomes the platform team on paper,
but everything else stays exactly the same.
They still function as a ticket shop.
Teams still file requests.
They still wait for manual approvals.
They still depend on two or three senior engineers
who are the only ones who understand the right way
to do things.
The platform team still exists to serve others, not to empower them.
It looks different on the org chart,
but the friction is identical.
So naturally, teams just bypass it.
The escape rate stays high while adoption stays low,
and the leadership wonders why the platform
is just a rebranding of the same old broken model.
The name matters less than the interaction.
If you didn't shift from approval workflows to self-service,
you didn't build a platform.
You just bought new business cards.
The second failure mode is over ambition.
A team decides they're going to build
the comprehensive platform that covers every possible base.
Kubernetes databases, networking security, CI/CD,
and cost management are all bundled together from day one.
The scope is massive.
The build takes a year.
By the time it finally launches,
the platform is so complex that the learning curve
is a vertical wall.
The documentation is thick, the features are endless,
and the teams using it have to understand
a mountain of new concepts just to get started
because there is so much service area,
there is also more that can break.
Teams don't trust it for their critical services,
so they build their own custom stacks for what matters
and use your platform for the stuff they don't care about.
The comprehensive platform becomes the default
for everything except the things
that actually drive the business,
which is the exact opposite of what you wanted.
The third failure is a lack of product thinking.
A platform team builds what they think is cool
instead of what developers actually need
to get their jobs done.
They optimize for technical elegance
and create the most architecturally pure solution imaginable.
They design for edge cases that almost nobody ever hits.
They build features that sound amazing
in a PowerPoint presentation.
And then developers use none of it.
It doesn't solve their actual problems,
the team confused technical perfection with user value,
but users don't care about how pure the code is.
They care about whether it solves their problem
faster than the alternative.
If it doesn't, they leave.
The fourth failure is a poor adoption strategy.
An organization decides to make the platform mandatory.
They tell everyone they have to use it
and announce they are killing off the old system.
But forced adoption without trust is just a recipe for resistance.
Teams use the platform because they are forced to,
not because it helps them.
They resent it, they complain about it.
They spend their time looking for ways to work around the rules.
Morale drops and the moment there is any slack in that mandate,
teams abandon the platform entirely.
Mandatory adoption is how you get the worst possible feedback.
People tell you what they think you want to hear
instead of telling you what's actually broken.
You miss the real pain points
because they're hidden under a layer of resentment.
The fifth failure is the measurement gap.
A platform launches and nobody tracks a single metric.
No adoption rates, no time to first deploy
and no data on developer satisfaction or ROI.
A year later, the team can't justify
why the platform even exists.
Was it faster?
Nobody knows.
Did it reduce the mental load on developers?
There's no data.
Did it save the company money?
You can't tell.
Without measurement, platforms have no story to tell.
They just exist and consume resources
until a new executive eventually asks
what the platform is costing the company.
When nobody can answer that question,
the project gets killed.
The sixth failure is a governance mismatch.
Sometimes policies are so strict
that they kill innovation before it starts.
Teams can't do anything without a signature
and governance becomes just another bottleneck in the system.
Developers give up and build shadow systems
because the official path is more locked down
than it is useful.
Or the governance is so loose
that it doesn't actually constrain anything at all.
Policies exist on a wiki somewhere,
but aren't enforced, security gaps emerge
and compliance becomes theater again.
The governance has to fit the organization
and its actual risk appetite.
Too tight and it strangles the platform,
too loose and it fails to govern anything.
These aren't technical failures.
They are organizational failures
and they are preventable.
The thinnest viable platform.
So how do you avoid those traps?
How do you build something that actually works
instead of something that just sits in the middle
helping nobody?
You start with constraint.
The thinnest viable platform is not just a buzzword.
It's a survival strategy.
It is the realization that your first version
doesn't need to cover every single use case.
It only needs to cover the ones that matter most.
The ones that show up every day.
The ones where the friction is the highest.
The principle is simple.
Start small, measure the impact
and expand only when there is actual demand.
Not because a feature sounds interesting,
but because you have evidence that people need it.
Most platform failures happen
because teams build too much, too fast
for problems that don't even exist yet.
They theorize about what teams might need
and design for scenarios that haven't happened.
They add features just because the architecture can support them
and then the platform launches to teams
that don't even recognize their own workflows in the tool.
A thinnest viable platform does the opposite.
It launches small, deliberately small.
You only ship the capabilities
that solve the most obvious high-friction problems right now.
Everything else waits.
Everything else can be built later.
Once you actually know what matters to your users.
So what does that first wave look like?
First, you have CICD pipelines.
This is universal because every team needs to build
and deploy code.
You create a standard pipeline that handles the build,
the tests and the security scanning.
You don't build every possible variation.
You build the one that works for 80% of your services.
Next is environment provisioning.
Developers need a place to test their work
and getting a dev or test environment
should be a self-service experience.
They should be able to push a button
and get an environment in minutes
rather than waiting days for a ticket to be processed.
Then you add basic observability.
This means logging, metrics and alerts.
It isn't a comprehensive, all-encompassing monitoring suite.
It's just the basics.
It's enough for a developer to see if something is broken.
Finally, you include security scanning.
Every deployment should run through automated checks
for vulnerable dependencies or secrets exposed in the code.
These vulnerabilities should be code automatically
and denied before they ever reach production.
That is the first wave.
Four capabilities, not 20, not 10, just four.
And they solve the most immediate problem.
How do we ship code safely and consistently?
Once this is live, you measure everything.
You look at how many teams are using the golden path
for their pipelines and how many are actually
using the self-service provisioning.
You track the time to first deploy
and the overall adoption rate.
If your adoption is below 70%, something isn't working.
It's not because the teams are lazy.
It's because the platform isn't solving their problem well enough.
You have to fix that before you even think about expanding.
You only add the second wave, once the first wave is solid
and widely adopted.
The second wave comes much later.
This is where you add cost governance
like tagging and budget alerts, or the automatic shutdown
of unused resources.
You might add advanced networking, multi-region connectivity,
or disaster recovery patterns.
These are important, but they aren't the first problem
teams face.
Developers can survive the first few months without them.
Once the platform is stable and trusted
and once teams are actually using it every day,
then you layer in those next capabilities.
The third wave is for specialized needs.
This includes data platforms, machine learning infrastructure,
or compliance patterns for regulated workloads.
You might add message cues or distributed caching here.
These are things that specific teams need,
but they aren't universal requirements.
By this point, your platform team understands the model.
They know how to build things that teams actually use
because they've already proven their value and earned that trust.
Now they have the permission to expand into specialization.
Here is why this works.
First, it keeps the platform team focused.
They aren't trying to build everything at once.
They are building one thing exceptionally well.
The learning curve for your user stays flat.
They only have to learn four things instead of 40,
so adoption follows naturally
because the platform solves a problem
without overwhelming them.
Second, measurement tells you immediately
if you're on the right track.
If adoption is low on that first wave,
you have actionable feedback.
You don't just hear that the platform is too complex.
You see that CICD adoption is at 45%,
which means teams don't trust the pipeline yet.
That is a specific problem with a specific fix.
Third, you prove the value before you place a massive bet.
If the first wave creates a 20% improvement
in how often you can deploy,
you have your proof of concept.
That success justifies the next wave of investment.
If adoption is high and teams are happy,
you have earned the right to grow.
You aren't gambling on what might work.
You are building on evidence of what already does.
The organizations that win with platforms
are the ones that resist the urge to do everything at once.
They start small, they measure the results,
and they expand methodically.
They watch those adoption rates like a hawk
because adoption is the only metric that actually matters.
Developer experience as a leading indicator,
we've spent a lot of time talking about measurement,
we've looked at adoption rates,
DORA, metrics, and cognitive load.
But there is one specific metric that sits above everything else.
It's the one number that actually predicts
whether your platform will succeed or fail.
And yet, most organizations
completely ignore it.
That metric is developer experience or DX.
But here is the thing, DX is not just a feeling.
It isn't something you measure in a yearly satisfaction survey
and then file away in a drawer, it is a quantifiable, measurable.
Predictor of whether your platform is actually doing its job.
And the reason that matters so much is that
high DX correlates with every single outcome you care about.
High adoption, low cognitive load, fast delivery,
and low burnout.
All of those things flow directly from the developer experience.
This isn't just theory, it's visible in how people act.
When a developer has a good experience with the platform,
they use it.
When the experience is frustrating, they build a workaround.
That isn't an opinion, it's a behavior, and behavior doesn't lie.
So what does DX actually look like in practice?
It's simple, how easy is it for a developer to do their job using your tools?
So I'm not asking how technically elegant the platform is.
Or how pure the architecture looks on a whiteboard, I'm asking.
Is it satisfying to use?
Can a developer get what they need without hitting a wall?
Or do they spend four hours a day fighting the system
just to get a single service running,
measuring this is straightforward?
You start with a net promoter score.
Asking one question, would you recommend this platform to a colleague?
You use a seven point scale, you get a number,
and that number tells you immediately if you're winning or losing,
but you don't stop there.
You pair that survey data with workflow telemetry
to see how much time people are actually spending in each tool.
If the data shows a developer is fighting the platform
for two hours to finish a task that should take 20 minutes,
the telemetry will flag it, then you add friction logs
looking for where people get stuck.
What questions keep popping up in Slack?
And which errors are flooding the logs?
When you combine the surveys, the telemetry and the friction logs,
you finally get a complete picture of the user experience.
Now, connect that back to Dora.
This is the real insight.
Teams with high DX scores report more frequent deployments
and shorter lead times.
Teams with low DX scores report more incidents and slower recovery.
That isn't a coincidence, it's causation.
When the platform is easy to use, developers use it more often.
When they use it more often, they deploy more frequently.
And because they are deploying all the time, they get better at it.
So they recover faster when things break,
the platform becomes invisible.
It just works.
So they ship faster.
But look at the opposite side.
Teams with low DX avoid the platform entirely.
They deploy less often because the platform feels like a bottleneck.
When they finally do ship code, they often use a manual workaround
that bypasses the official guardrails.
So when a failure happens, they aren't practiced at recovery.
They don't have the right observability
because they weren't using the standard stack.
It takes them longer to find the problem and even longer to fix it.
This is why DX is a leading indicator.
It predicts your door or metrics before they even happen.
If you measure DX today, you already know if your door or metrics
will improve or crash six months from now.
You don't have to wait half a year to see if adoption is working.
The DX score tells you right now if you're on the right path.
But here is what most leaders miss, the actual business impact.
Developers who report a good experience are 50% more likely to say
they are satisfied with their job, 50%.
That isn't a small detail.
It's a massive business advantage.
Satisfied developers stay at the company.
They don't leave for the next recruiter who calls.
They mentor the junior engineers.
They tackle the hardest problems.
And they actually care about the quality of the code they ship.
On the other hand, developers with low DX are burning out.
They spend their entire day fighting tools that are broken.
They waste their mental energy on frustration
instead of solving business problems.
Eventually, they start looking for the exit.
Replacing a senior engineer costs anywhere from 200,000 to $500,000.
If a bad developer experience causes just two engineers
to leave a team of 20, you are looking at a million dollars
in replacement costs every single year.
And that's just the cash.
It doesn't count the loss productivity while the seat is empty.
The time it takes to train someone new.
Or the institutional knowledge that just walked out the door.
Now, scale that across the whole company.
If you have 500 developers struggling with a bad platform,
and each one is 5% more likely to quit,
you are losing millions of dollars,
in a voidable turnover.
That is why DX is no longer a nice to have.
It is a hard business metric.
It affects your retention, your productivity,
and your ability to compete.
A company where the platform works is a company where engineers stay.
And engineers who stay are the ones who ship better code faster.
Cognitive load reduction is the North Star.
Everything we've talked about so far, the golden parts,
the automation, the product mindset,
it all exists for one reason.
And if you lose sight of this one goal, the whole thing falls apart.
That goal is cognitive load reduction,
not simplification for the sake of it,
not technical purity, cognitive load reduction.
The ability to let a developer focus on the business problem
instead of the infrastructure around it.
Think about what this looks like in the real world.
Cognitive load is just the mental effort it takes to do a task.
When you're building a new feature,
your brain is already juggling a dozen things, the business logic,
the design patterns, the edge cases, the security concerns.
That is the intrinsic load, it's the work, it's necessary.
But then, we pile on the toil.
Cloud configurations, networking setup, storage provisioning,
observability wiring, and compliance checks.
All of that takes mental effort too,
but it has nothing to do with the business problem.
It doesn't make the feature better.
It just consumes the mental capacity that should have gone
toward the actual product.
This is where the measurement gets real.
We look at concepts to ship.
How many different things does a developer have to understand
just to get code into production?
In a manual environment, the answer is exhausting.
You have to understand Kubernetes networking primitives,
RBACCY, and persistent volumes.
You're worrying about ingress controllers, storage classes,
log aggregation, and image signing.
That is 15 or 20 different concepts
a developer has to hold in their head at the same time.
A mature platform reduces that down to four or five concepts.
Service name, environment, number of replicas, and resource limits.
That's it.
Everything else is hidden.
The platform handles the complexity.
This isn't abstract.
It's measurable.
If you give a developer a form with five fields,
they can fill it out in five minutes.
If you give them a spreadsheet with 15 complex options,
they will either get it wrong or spend two hours
researching the right answer.
That gap is the cognitive load,
and the difference in how fast they ship is something you can track.
But here is why cognitive load reduction is the North Star.
It isn't just about speed.
It's about everything else.
Lower cognitive load means faster onboarding
when a new engineer joins.
They don't have to spend three weeks learning infrastructure
before they can deploy.
They learn the platform in three days.
And they ship code in a week instead of a month.
That speed compounds across the entire organization.
Lower cognitive load also means fewer bugs
when a developer is exhausted
from making infrastructure decisions.
They get distracted, they're tired, they miss things,
and they rush through testing
because they just want to be done.
A platform that removes those decisions
lets that mental energy go back into the code.
Fewer bugs follow naturally.
It also leads to better architecture.
Senior engineers stop spending their time explaining
the right way to set up a database
and start focusing on system design.
They mentor differently.
They coach people on architecture instead of operations.
So the code base gets cleaner
and the systems become easier to maintain.
And finally, lower cognitive load
leads to higher job satisfaction.
This is the through line.
Developers who aren't drained by infrastructure
toil actually enjoy their work.
They aren't frustrated, they aren't burning out
and they stay at the company.
This is why cognitive load is the North Star.
It isn't a metric that stands alone.
It's the lever that moves everything else.
Dora metrics improve because developers aren't fighting the system.
Adoption climbs because the platform is actually usable.
Retention improves because people aren't exhausted.
The organization ships better code faster.
With engineers who are actually happy to be there,
everything you are building is in service of this one outcome.
If your platform doesn't reduce cognitive load,
you might have built something sophisticated,
but you haven't actually solved the problem.
The AI governance layer, you've built a solid platform.
Golden paths, infrastructure as code,
policies that enforce themselves,
developers are shipping fast because governance
is embedded into the workflow.
Everything is auditable.
It's a clean system.
And then M365 co-pilot enters the picture.
This is where the model breaks.
Because an AI agent isn't like a developer.
A developer reads the documentation.
They understand the constraints of the system.
They make deliberate human choices.
An AI agent doesn't do that.
An AI agent simply looks at what it has access to and uses it.
If your infrastructure is inconsistent,
the agent operates inconsistently.
If there are security gaps, the agent inherits them.
If your governance is manual, the agent can't follow it.
The floor is inheritance.
When your infrastructure is manually configured,
inconsistencies are scattered everywhere.
One team sets up a database with encryption
while another team leaves theirs dark.
Networking rules vary from one department to the next.
Access controls are ad hoc.
A developer navigating this mess
makes a conscious choice about which pattern to follow.
They bring context.
They bring judgment.
An AI agent doesn't.
The agent encounters the infrastructure exactly as it exists.
If it can access a resource, it will.
If it is permitted to create something, it creates it.
The agent doesn't know that one team's database
is misconfigured and should be avoided.
It doesn't know that creating a public IP
violates your security posture, even if the system technically
allowed the API call.
The agency's a landscape of APIs and permissions.
It doesn't see the intent behind the configuration.
So when you deploy AI agents into an inconsistent environment,
they amplify the mess.
They find the gaps.
They exploit them.
Not because they're malicious, but just because they can.
A copilot agent trained on your code base
will use whatever patterns it finds.
If your services are misconfigured,
the agent will generate code that matches those broken
patterns.
It propagates the problem.
This is the governance challenge at the agent layer.
You can't rely on agents to understand what they shouldn't do.
You have to make it impossible for them to do it.
The solution is to embed governance at the API level.
When an AI agent calls an API to create a resource,
that call must hit a policy check before anything happens.
The policy verifies the permissions, the encryption,
the security posture, and the data residency rules.
If any check fails, the call is denied.
The agent doesn't get an error message.
It might misinterpret.
The action simply doesn't happen.
This requires the infrastructure you've already built.
The policy as code prevents the wrong actions,
while RBAC ensures agents only touch what they should.
Audit trails log every move so you know exactly what happened
and when.
But you need a new layer on top.
Agent identity every AI agent is a principle.
It has credentials.
It has permissions.
It has accountability.
When co-pilot interacts with your infrastructure,
it does so with a specific identity.
Every action is logged to that identity, meaning you can trace
every infrastructure change back to the specific agent that made it.
Measurement shifts to compliance score becomes the percentage
of AI actions that actually meet your policy.
If an agent tries to violate a rule, that counts as a failure.
You see immediately if an agent is behaving outside the guard rails.
The outcome is safety at scale.
You can enable AI agents to interact with your systems
without creating new risks.
They operate within the boundaries you've defined.
They can't create something insecure because the policy prevents it.
They can't access data.
They shouldn't because RBAC blocks it.
They can't operate in the dark because every action is audited.
This is where automation and AI safety converge.
You've simplified the decision so much
that agents can navigate the system safely.
Your policy automation is so full that agents inherit compliance
instead of chaos.
Migration path.
From manual to platform driven.
So you've decided to build a platform.
You understand the tax.
You understand the cost.
You understand what success looks like.
Now the question is, how do you actually get there?
How do you move from teams scattered across a fragmented landscape
to a unified platform?
The path is six phases.
It takes 18 to 24 months to reach a functioning adopted platform.
It's not fast, but it's faster than continuing to pay the tax.
Phase one is baseline and discovery.
This takes about three months.
You don't start building it.
You start measuring.
You look at your door on metrics to see how often deployments break
and how long recovery takes.
You run a survey to measure cognitive load.
How many concepts does a developer need to understand
just to get code live?
You identify the pain points by talking to the teams.
Ask them where they get blocked
and when they give up and build a workaround.
Usually the answer is environment provisioning
or deployment pipelines.
Friction is high there.
The return on solving it is immediate.
Phase two is building the thinnest viable platform.
This happens between months, four and six.
You focus on the 80% case.
Don't try to solve every edge case.
Solve what most teams need.
Start with a standard CIS/CD pipeline
that handles the basics like testing and security scanning.
Then move to environment provisioning.
Developers need to be able to push a button
and get a test environment in minutes.
Add the fundamentals of observability,
like logging and alerts,
and build security scanning into the pipeline.
These four capabilities solve the most obvious problems.
Phase three is piloting with early adopters.
This covers months 7 through 9.
You don't launch to the whole company.
You launch to two or three teams
who actually want to make it work.
You work closely with them
and watch how they use the platform.
You see what breaks and what feels unclear.
You gather feedback relentlessly
and refine the system based on real usage, not theory.
These pilot teams become your advocates
because they see the benefit every day.
Phase four is expanding adoption.
This takes you through the end of the first year.
You roll out to more teams gradually.
You use enabling teams like Cloud Coaches and SRE Guides
to help people adopt the new way of working.
Their job isn't to force adoption, it's to support it.
You watch the metrics.
If adoption is stalling, you ask why?
Is the platform not solving the problem?
Is the documentation confusing?
You fix the platform, not the teams.
Phase five is measure and optimize.
This happens between months 13 and 18.
You track adoption rates and developer satisfaction.
You check if the concepts to ship numbers
are actually going down.
You look at the door metrics for the teams using the platform.
If adoption is stuck at 50%,
you investigate the friction before you try to expand the scope.
Phase six is expanding scope.
This is the final stretch from month 19 to 24.
Only now do you add specialized capabilities
like cost governance or advanced networking.
You add these because teams have proven they trust the platform.
You've earned the right to expand.
The entire timeline is 18 to 24 months.
It sounds long, but compare it to the cost of doing things manually
for another five years.
18 months to transform how your organization operates is fast.
The key is discipline.
Don't skip phases.
Don't try to build everything in phase two.
Don't launch to everyone before you've refined the system
with your pilots.
The phases exist because they work.
The ROI story.
None of this matters if you can't justify the investment.
So let's look at the business case.
Most organizations spend 20 to 30% of their engineering capacity
on infrastructure, toil, not on architecture, not on design,
just toil.
This is the repetitive, non-differentiating work
that eats up time without creating any value for your customers.
If you have 100 person engineering team,
that means 20 to 30 people are essentially stuck.
Their job description says engineer.
But their daily reality is just keeping
the infrastructure from falling apart.
They aren't shipping features.
They aren't solving customer problems.
They are running runbooks, answering the same questions
about deployments and debugging networking issues
over and over again.
They spend their days reviewing infrastructure changes
or sitting on call for outages.
None of that work ever shows up on a product roadmap.
It doesn't generate revenue.
It's a tax.
Now, let's put a dollar amount on that tax.
The fully loaded cost for an engineer is roughly $150,000
per year once you factor in salary, benefits, and overhead.
30 engineers at $150,000 each adds up to $4.5 million
every single year.
That is $4.5 million spent on infrastructure toil
that could have been spent building things people actually pay for.
This is your baseline.
This is what you are paying right now.
You don't see it as a problem because it's baked into your planning.
The money leaves your budget,
but it doesn't show up as a line item called infrastructure tax.
It's just buried in engineering capacity.
You assume you need these people, you budget for them,
and you move on.
But you never stop to ask what if we didn't need to work this way?
Now look at the platform investment.
A mature platform team usually costs between $1.2 million per year.
That covers the salaries for platform engineers, architects,
and product managers plus the cloud costs in tooling.
Compare that $2 million investment to the $4.5 million
you are currently losing to toil.
Here is the payoff.
If the platform cuts that toil by just 50%,
you recover over $2 million in developer capacity.
You are spending $2 million to get $2.4 million back.
That's a net gain in year one.
But the math gets even better in year two.
Your platform costs stay steady at $1.2 million,
but adoption is now much higher.
More teams are using the golden paths.
Cognitive load is dropping.
Time to first deploy is faster.
The toil doesn't come back, so your payoff stays high
while your delivery metrics start to multiply.
By the second year, you have recovered the entire investment
and you're seeing net savings.
By year three, those savings compound.
You built the platform once,
and now it operates at scale without the team leading to grow.
The money that used to flow into the void of toil
is now flowing directly into features.
That's how you build a competitive advantage.
Mature platforms report between 208% ROI
within 18 to 24 months.
That isn't a theory.
That is what's being reported from actual implementations.
200% means you get $2 back for every dollar you put in.
The range is wide because it depends
on how much you're struggling right now.
If you are drowning in toil, your return will be closer
to that 800% mark.
The timeline is the only catch.
18 to 24 months is longer than a single quarterly budget cycle.
It requires patience.
It requires leadership that looks past the next three months.
But here's the alternative.
You can keep paying the tax forever.
You can keep losing $4.5 million a year indefinitely.
The choice isn't actually between investing and not investing.
You are already spending the money.
The only question is whether you're spending it
on building features or spending it on the overhead
that prevents those features from being built.
Common objections on how to answer them.
You're going to hear pushback.
It will come from engineering leaders, product managers,
and definitely the CFO.
The objections are predictable. They sound reasonable.
Until you look at what they're actually saying,
the first one is the most common.
We don't have time to build a platform.
We need to ship features.
This one is tough because it's true.
You do need to ship.
The market doesn't care about your internal tools.
So why spend months building something
the customer never sees?
The answer requires a shift in how you look at time.
You aren't choosing between a platform and features.
You're choosing where the toil goes.
Right now, your teams are trying to ship features
while they manage infrastructure at the same time.
They are doing both and they are doing both badly.
Context switching is a productivity killer.
So the real question is, can you afford not to build this?
The time is already being spent.
It's just being spent inefficiently by everyone at once.
A platform consolidates that work.
It moves the infrastructure burden to one dedicated team
and frees everyone else to focus on the product.
You aren't losing time.
You're relocating it.
And that relocation is exactly what makes
you ship faster in the long run.
The second objection is about variety.
Our teams are two different.
We can't have golden paths.
Every organization thinks they are a special case.
They think their architecture is too complex
or their constraints are unique.
Maybe some of that is true.
But in reality, 80% of what your teams do is exactly the same.
They create a service.
They deploy it.
They monitor it.
The 20% that is actually different is handled by escape hatches.
The golden path covers the bulk of the work.
If a team has a legitimate edge case,
they work with the platform team to build a solution.
But that is the exception.
It isn't the rule.
The mistake is assuming the exceptions happen
more often than they actually do.
The third objection comes from past trauma.
We tried a platform before and it failed.
This is just a scar tissue.
Maybe a previous initiative didn't work
or teams refused to use it.
It's a fair concern.
But the failure wasn't because the concept of a platform
is flawed.
The failure was organizational.
Either it was built without talking to the developers
or it was never measured or it was a top-down mandate
that made everyone's life harder.
This time is different because you
are treating the platform as a product.
You are measuring adoption.
You are focusing on the developer experience.
You are starting small and expanding
based on what the evidence tells you.
The fourth objection is about speed.
Governance will slow us down.
People hear governance and they think of manual reviews
and approval workflows.
Those are bottlenecks.
But policy is code isn't a bottleneck.
It's automation.
A policy check runs in milliseconds.
It approves or denies based on clear rules.
There is no human in the loop
and no waiting around for a meeting.
This makes governance faster than the alternative.
It's much better than a developer spending three days
working on something only to find out it violates
a security policy later.
The last objection is the most practical.
We can't afford to build this.
It's a fair question.
Where does the money come from?
The budget answer is that you're already spending it.
The platform costs two million
but you're losing four and a half million to toil.
Right now, you are just redirecting the spend.
But the deeper truth is that you can't afford to wait.
The cost of doing nothing compounds every single year.
Every year you delay is another year
you pay that four and a half million dollar tax.
The ROI of the platform only gets clearer
the longer you wait to start.
These objections aren't really about the technology.
They are about a fear of change
and the memory of past failures.
Those feelings are legitimate.
But they aren't arguments against building.
They are arguments for building thoughtfully.
Start small, measure everything and grow
based on what actually works.
The future state, what success looks like.
Imagine it six months after you launched the platform.
A new developer joins the team on a Monday morning.
By Tuesday afternoon, she has already shipped her first change
to production, not a staging environment,
not a local branch, production.
She provisioned the environment herself.
She deployed the code, she saw the results live.
And the entire process took about four hours
compared that to 18 months ago
when that same developer would have spent three weeks
just learning infrastructure concepts
before shipping a single line.
The real difference here isn't just speed, it's psychology.
She isn't intimidated by the system.
She isn't drowning in tickets.
She is productive on day one
because the platform made the right way, the easy way.
If you walk through the code base now,
you'll see that 80% of services follow the same golden path.
They use the same deployment steps,
the same security posture and the same patterns.
This isn't about restriction, it's about clarity.
Teams use the standard approach because they know it works.
They know it's been tested
and they know support is actually there if they need it
for the 20% that need something unique.
They have escape hatches, they collaborate
with the platform team to build what they need.
But the standard remains the default
when you ask a developer where her time goes.
She'll tell you 80% is spent on features.
She's designing systems.
She's writing code.
She's thinking about customer value.
Only 20% of her time goes to infrastructure tasks
like provisioning or debugging compliance checks
before the platform.
That ratio was completely inverted.
The cognitive energy that used to be scattered
across tool decisions is now consolidated into one place.
Her mind is finally free for the work that actually matters.
The concept to ship metric is holding steady at four.
Service name, environment, replica account, resource limits.
Everything else is abstracted away.
A new engineer doesn't need to understand
Kubernetes networking or reason about ingress controllers
because those things are invisible.
She talks to the platform in her own language.
Not the language of the infrastructure.
Look at the adoption numbers.
85% of teams use the platform for their standard needs.
Not because of a mandate, but because it works.
They use it because it's faster than the alternative.
They use it because the documentation is clear.
They use it because when something breaks,
support is immediate.
Voluntary adoption is the only proof point that matters.
If teams are using it willingly, you solve the right problem.
Governance no longer feels like friction.
It's invisible.
When a deployment runs, policy checks happen in milliseconds.
The code either moves forward or fails based on automated rules.
There is no approval workflow, no bottleneck, no waiting.
Security teams finally sleep at night
because policies are enforced at the point of action.
Not weeks later, during a manual audit,
measurement is now continuous.
You can open a dashboard and see adoption metrics in real time.
You see that time the first deploy is down to four hours
and the change failure rate has dropped by 60%.
Deployment frequency has tripled.
Lead times have been cut by 70%.
The metrics are green because the platform
is doing exactly what it was designed to do.
Even AI agents can operate safely now
because governance is embedded.
When a tool like co-pilot tries to create a resource,
the policy engine evaluates that request before it happens.
The agent can't accidentally create something insecure
because the platform simply won't allow it.
The audit trails show exactly what happened and when.
Governance is tighter than ever, but it's invisible.
The agent just works within the guardrails.
The choice, the DevOps Tax is real.
It is costing your organization millions of dollars
every single year.
It's an invisible cost, built into salaries,
and burned into engineering capacity
that should be going toward building.
Platform engineering is the correction.
It isn't just a new philosophy or DevOps 2.0.
It is a structural shift in how we work.
It's the move from treating infrastructure as a shared burden
to treating it as a product.
The path forward requires four elements,
golden paths that make the best choice the easiest one,
infrastructure as code that makes every setup reproducible.
Policy as code that replaces manual processes with automation
and team topologies that organize people around flow.
Instead of function, but none of this works without measurement.
Cognitive load, developer experience, adoption rates,
these aren't optional metrics.
They are the only way you know if you're actually winning.
The outcome of this shift is liberation.
It means developers who ship faster and safer with less burnout.
It means large organizations that can move
like companies a tenth of their size.
It creates a competitive advantage that compounds over time.
The invitation is simple.
Start small.
Measure the impact.
Expand incrementally.
Don't try to build everything at once.
Build what matters.
Prove that it works.
And then grow.
The tax is real.
But it doesn't have to be inevitable.