Welcome to another episode of Microsoft Knowledge Nuggets on M365.
FM, I'm your host, Mirko Peters.
Today's topic is one that nearly everyone has heard of,
but few really understand, platform engineering.
You've probably heard about DevOps,
the idea that developers and operations teams work together seamlessly,
but somewhere along the way that promise got messy.
Developers ended up doing ops work, that system broke.
By the end of this episode, you'll understand
what went wrong with DevOps,
what an internal developer platform actually is,
how golden parts give teams a clear road to follow,
and why the smartest engineering teams are already building one.
The mess DevOps left behind.
Let's go back to where it started.
DevOps was a great idea with a simple goal,
break down the walls between developers and operations,
no more throwing code over the wall and hoping for the best.
Shift left, move testing, security and operations earlier in the process,
faster delivery, fewer hand-offs, more ownership.
On paper, it looked perfect.
In practice, something went wrong.
Shift left didn't just shift responsibilities.
It piled them on.
The developer who used to write code and file a ticket
now owns infrastructure, security, monitoring, Kubernetes,
CI/CD pipelines, secret management,
and about 15 cloud services they'd never heard of before.
One person handles all of that while still building the actual product.
Here's what that looks like in real life.
A team wants to spin up a new environment to test a feature.
Before DevOps, they'd file a ticket and wait.
After DevOps, they own it themselves, which sounds great in theory.
But now they need to write terraform modules,
configure a Kubernetes cluster,
set up networking rules,
wire up monitoring, figure out secrets, management, and make sure security policies are applied.
What used to be a ticket that took someone else an hour
now takes three days of a developer's time.
Three days, they're not writing product code.
They're fighting YAML files and debugging why the load balancer isn't rooting traffic correctly.
The mental load here is enormous.
Every team ends up building their own pipelines,
deployment scripts, and monitoring dashboards.
And because everyone's stretched, then corners get cut.
Security gets skipped because the deadline is Friday.
Cloud builds double without anyone noticing
because nobody remembered to shut down the test environment.
And when something breaks at 2 a.m.,
the developer who built it is the only one who can fix it.
This isn't sustainable.
And here's why it matters more than ever.
Cloud complexity keeps growing.
Every year there are more services, more tools, more decisions to make.
And now AI coding tools let developers ship code faster than ever.
10, 20, even 30 times more code per day.
But all that code still needs infrastructure, security, and monitoring.
More code without a better system just means faster chaos.
If you feel like you're drowning in YAML and Terraform, you're not alone.
This isn't a personal failure.
It's systemic.
The model broke.
What platform engineering actually is.
So what's the fix?
It's called platform engineering.
And here's the simplest way to think about it.
This discipline creates an internal layer
that absorbs complexity for developers.
Imagine walking into a large office building.
You don't need to worry about who has access to,
which floor, which security badge works,
or where the fire exits are.
The reception desk handles all that for you
and you just walk in and get to work.
That's exactly what platform engineering does for your developers.
Instead of every single developer needing to become an expert
in Kubernetes, Terraform, networking, and security,
a central platform team creates a layer
that manages all that complexity.
The developer gets a simple interface.
Click a button, run a command, fill out a form,
and the platform takes care of everything else.
But here's the thing.
This isn't the same as DevOps.
DevOps taught every team to own their own infrastructure,
but platform engineering says that's a recipe for burnout.
Instead, the platform team provides paved roads,
standard, tested, and secure ways to handle common tasks.
They build and maintain the road,
while product teams just drive on it.
The core outcome of platform engineering
is something called an internal developer platform,
or IDP for short.
Think of it as a self-service system
that automates all that repetitive work.
Infrastructure provisioning, CI/CD pipelines,
security checks, monitoring, all built-in and standardized.
Here's a concrete example.
When a developer wants to deploy a new service without a platform,
it's been days setting up infrastructure,
writing pipelines, and configuring monitoring.
With an IDP, they just click "Deploy" in a UI
or run a single command.
And the platform handles everything,
provisioning, tests, monitoring, deployment,
all in minutes instead of days.
So what does this mean for you?
You stop being a jack-of-all infrastructure
and start being a specialist in your actual product.
Your job goes back to building features
that matter to your customers.
Instead of debugging why your Terraform state file is corrupted,
that's the whole point.
The internal developer platform in plain English.
So let's break down what an internal developer platform
actually is.
It's the engine that combines everything into one system.
Your CI/CD pipelines, infrastructure templates,
security policies, monitoring, and logging.
Instead of six separate tools, you have to wire together.
Here's an analogy.
Think of it as "cooking from scratch" versus using a vending machine.
"Cooking from scratch" means buying ingredients,
chopping vegetables, measuring spices, monitoring the stove,
lots of decisions, lots of steps, lots of ways to mess up.
A vending machine gives you a result with one button press.
Fewer decisions, faster outcome, consistent quality,
and IDP is that vending machine.
The developer doesn't need to know how infrastructure is provisioned
or where secrets are stored.
They just press the button.
What's inside that vending machine?
The core components are pretty standard.
CI/CD templates for consistent builds,
infrastructure provisioning for automatic environment spin-up,
secret management, so credentials aren't floating around in config files,
and logging with built-in observability
so you can troubleshoot without scrambling.
All of it pre-configured, tested, and maintained by the platform team.
Here's a concrete example.
A developer types create new service into a command line
or clicks a button in a portal.
Behind the scenes, the IDP spins up a new repository with the right structure,
sets up a build pipeline that runs tests automatically,
deploys the service to a development environment,
and adds health check endpoints with logging.
All of that happens in minutes.
The developer never touched a single terraform file
or configured a Kubernetes manifest.
Just type to command and got a running service.
Why does this matter?
Consistency is the key reason.
When every team builds their own pipelines and writes their own deployment scripts,
you end up with snowflake configurations,
50 different services, 50 different ways of doing things.
When something breaks, nobody can debug it except the person who built it
and if that person left the company, good luck.
An IDP eliminates that by making every service follow the same patterns,
every deployment uses the same pipeline and every team get the same defaults.
When something breaks, the patterns are familiar and the fix is documented.
So here's what this means for you.
If your organization has 50 teams doing deployment 50 different ways,
an IDP is the solution.
It doesn't mean teams lose autonomy.
It means the boring, repetitive, error-prone parts get standardized
so the interesting creative work can vary.
That's a trade-off worth making.
Golden parts, the way, not a cage.
Let's talk about golden parts.
You've probably heard the name, but the idea is simple.
A golden path is a recommended pre-built workflow
that makes the right thing the easiest thing to do.
Your platform team says, "Here's how we suggest you do this."
We've tested it, it works, and we'll back you up if something breaks.
Notice that word recommend.
Golden parts aren't mandatory.
Developers can step off the path if they need to,
but the path is the fast-safety fault.
It's already running, supported and documented.
You don't have to figure everything out from scratch.
Think of it like railway tracks instead of guard rails.
Guard rails catch you when you crash.
They react, they stop you from going off a cliff,
but they don't help you steer.
Railway tracks guide you smoothly along the route
so you don't have to decide where to turn.
Golden parts are the tracks, they move you forward,
not just catch you when you fail.
Here's where a lot of teams get this wrong.
They build golden parts for the platform team,
not for the developers.
They optimize for architectural purity or security compliance
or some internal rule nobody outside the platform team understands.
The result looks great on a whiteboard, but feels terrible to use.
Developers quietly find workarounds, adoption drops,
and the platform team wonders why nobody appreciates all that effort.
The fix is simple, but it's hard to do.
You need escape hatches.
If the path doesn't fit a developer's use case, they need a way out.
A way to override a default,
bring their own pipeline or step outside the platform entirely.
And here's the important part.
When they step off, that's not failure.
It's feedback.
Every time a developer leaves the golden path, it tells you something real.
Either the path is missing a feature it should have,
or the use case genuinely doesn't belong there.
Both signals are valuable.
A good golden path in practice looks like this.
A team wants to deploy a new backend service.
They use the path.
It gives them a template repository with the right structure,
a standard CI/CD pipeline that's already tested.
Built in logging and monitoring,
a one-click rollback if something goes wrong.
The whole thing takes minutes instead of days,
and because the platform team maintains the path when something breaks,
they fix it.
The developer doesn't have to become a pipeline debugging expert.
What this means for you, fewer surprises.
You ship faster because the path is tested.
You ship safer because security and monitoring are built in.
You ship with confidence because rolling back is one-click.
The path exists to help you, not to hold you back.
Use it, cutting cognitive load.
Here's where the real payoff shows up.
When a platform handles the heavy lifting,
developers can actually focus on code.
They don't need to know which Kubernetes version is running.
They don't have to update Terraform modules every time a cloud provider changes in API.
They just write features.
Platform engineers absorb that complexity.
They decide what developers need to see and what should stay hidden.
That's a real design choice, not just a technical one.
It's about figuring out which details matter to the person using the platform
and which ones just add noise.
Here's a concrete example.
A developer deploying a new service doesn't care about cluster node sizes,
instance types, or auto scaling thresholds.
They care about whether their service runs
and how fast it responds.
So the platform pre-configures all that based on the app tier.
Small service, here's the right setup, high traffic service,
here's a different configuration.
The developer doesn't make those choices because they don't need to.
Why does this matter?
Because burnout drops when developers aren't juggling 15 different concerns at once.
Some mature platform teams have cut cognitive load by nearly half.
40 to 50% less mental overhead.
That's a huge shift.
It's the difference between leaving work with energy left
and staring at a terminal at 10pm wondering why your pipeline failed.
But here's the warning, don't create illusions.
Some platform teams fall into a trap.
They hide settings without giving developers any way to understand
what's happening under the hood.
That's not abstraction, that's trickery.
And it backfires the moment something goes wrong,
developers hit a wall they can't see through
and suddenly the platform feels like a black box working against them.
The term for this is a leaky abstraction.
You hide complexity, but eventually that complexity leaks out.
A database gets slow, a deployment fails,
a security policy blocks something unexpected.
And the developer has no mental model of what's happening
because the platform never gave them one, transparency matters.
Show developers what they need to know when they need to know it.
Don't just hide everything and hope for the best.
What this means for you, less context switching and more flow state.
You don't start your morning wondering if the Kubernetes cluster needs an upgrade.
You start your morning working on the feature due next week.
Your job becomes your actual work again.
Treating the platform like a product.
Today we're talking about something that changes
how internal tools actually work.
Most people think a platform team is just an infrastructure team.
It isn't a platform team is a product team.
And the developers using that platform are their customers,
not people filing tickets.
That changes everything.
A product team talks to its customers.
They find out what's actually painful.
They prioritize features based on real need.
They measure adoption.
They don't build something and walk away.
They keep iterating.
So what does a product team look like in practice?
They don't operate like a help desk.
A developer files a ticket.
And the platform team does it manually.
That's not platform engineering.
That's just centralized operations with a new name.
It doesn't scale.
It doesn't reduce cognitive load.
It just moves the bottleneck from one team to another.
Here's what they do instead.
They measure the right things.
Time to first deploy.
Onboarding speed for new team members.
Developer satisfaction scores.
These are the metrics that tell you
whether the platform is actually helping people
or just adding another layer of complexity.
Spotify is a good example.
Their platform team runs like a proper product organization.
They have roadmaps.
They have OKRs.
They talk to developers about what is working and what isn't.
They treat the platform as something that has to earn
its adoption every single day.
And that is the main idea.
A platform nobody uses is just a project.
It's gathering dust in a corner.
Adoption is the ultimate validation.
If developers choose your platform
over building their own tools,
you have done something right.
If they avoided no amount of technical excellence can fix that.
What does this mean for you?
It means if you are building a platform.
Don't start with architecture diagrams.
Don't start with Kubernetes clusters or terraform modules.
Start with user interviews.
Talk to the developers who will use your platform.
Find out what is actually painful.
Build one thing that solves the real problem.
Then iterate.
That is how you build something people actually want to use.
Why right now?
The AI wave.
So why are we talking about this right now?
Why not five years ago?
The answer is AI.
AI coding tools like GitHub co-pilot.
Let developers ship code at a pace we have never seen before.
10 times, 20 times more code per day than what was possible
just a couple of years ago.
But that sounds amazing.
And it is.
But here's the catch.
All that code still needs infrastructure.
It still needs security.
It still needs to be deployed, tested and operated.
More code without a better system does not make you faster.
It just makes the chaos faster.
If your developers are already drowning in YAML and Terraform,
AI does not fix that.
It just means they drown faster while producing more code
that needs to be supported.
Right now about 55% of organizations have already adopted
platform engineering in some form.
Gardner predicts that number will hit 80% by the end of 2026.
That is not a slow trend.
That is a shift happening right now.
Companies are realizing they cannot scale their engineering teams
without a platform layer.
The old approach of every team doing everything themselves
just doesn't work when you are shipping code at AI speed.
Here's what a lot of people miss.
AI does not just create the need for platforms.
It also helps build them.
Platform teams are using AI to generate Terraform modules,
write documentation and debug pipelines.
The same technology creating the urgency is also providing
the tools to solve it.
Now a word of caution.
AI amplifies whatever you already have.
If your fundamentals are solid,
like good architecture and a well-designed platform,
AI makes you two to three times more productive.
But if your foundations are weak,
AI just helps you make bigger mistakes faster.
Bad configuration, security holes, broken infrastructure,
all shipped to production before anyone catches it.
AI doesn't fix bad foundations.
It exposes them.
Here's a real example.
A company with a good internal developer platform
can let a non-engineer safely deploy AI tools.
The platform provides guardrails.
It enforces security policies.
It handles the infrastructure.
So a product manager can spin up an AI-powered prototype
without needing to understand Kubernetes or cloud networking.
That is powerful.
That is the kind of thing that separates teams
ready for the AI era from teams that are going to get left behind.
What does this mean for you?
The window to build a platform is closing,
not because the technology is going away,
but because the gap between teams with platforms
and teams without them is widening fast.
Every month you wait,
the teams that already have platforms are pulling further ahead.
They are shipping faster, burning out less,
and adapting to new tools more quickly.
The teams without platforms are falling further behind,
the choice is yours.
Start with one golden path.
So where do you actually start?
If you're sitting there thinking you need to build a whole internal developer platform
from scratch, stop.
That's the fastest way to kill your project before it even starts.
The biggest mistake teams make?
Trying to build everything at once?
They spend months designing the perfect platform,
packing in every feature they can think of.
Then they launch it, and hear nothing.
Nobody uses it.
Why? Because it solves problems nobody asked about,
and just getting started requires reading a small manual.
Here's the thing.
Don't do that.
Instead start small.
Actually talk to developers,
not the architects, not the managers,
not your own assumptions, find the people writing features every day.
Ask them where it hurts.
Find the one workflow that takes the longest,
frustrates the most people,
or gets skipped more than it should,
then build exactly one golden path all the way through.
Maybe it's create and deploy a new microservice.
Maybe it's set up a development environment from scratch.
Maybe it's ship a hot fix to production without breaking anything.
Pick the one that stings the most and build a path that makes that pain disappear.
Build it.
Test it with real users.
Collect feedback.
Itterate.
Then add another path and another after that.
Don't try to solve every problem at once.
Solve one problem really well and let the momentum carry you forward.
How do you know it's working?
Measure the right things.
Time from idea to first deploy.
Number of manual steps you've eliminated and voluntary adoption rates.
If developers choose your path over building their own,
your winning.
If they're avoiding it,
listen and change direction.
Here's the trap to avoid.
Don't make the platform mandatory.
Force developers onto your path and they'll resent it.
They'll find ways around it.
They'll build their own scripts and hide them from you.
Instead make the path easy.
Make it faster than the alternative.
Make it the obvious choice.
But never the only one.
The first path is always the hardest.
It teaches you everything about product thinking.
You learn how to talk to users, how to prioritize.
And that building something people actually want
is way harder than building something that just works.
But once you've done it once, the second path gets easier
and the third is easier still.
You're not building a platform in one shot.
You're building it one path at a time.
So that's the system.
Platform engineering is about building the paved road.
So developers can focus on driving instead of fixing portals.
If you're tired of fighting infrastructure,
start by finding one golden path on your team, just one.
Share this with someone who needs to hear it
and subscribe for more breakdowns just like this.