DevOps Is Dead. Platform Engineering Is Where Ops People Go Next

The short version

The DevOps job title is dying. The DevOps idea is not.

If you run infrastructure for a living, the role you'll be hired into in two years is "platform engineer," and the work looks different from what you do now. Less clicking through a cloud console, more writing code that other engineers consume as a product. Gartner expects 80% of large software organizations to have platform teams by 2026, up from 45% in 2022. In the Kubernetes job market, platform engineer postings have already outnumbered DevOps postings in 3 of the last 6 quarters, and they pay around 20% more.

That's the headline. The honest version has a catch, and I'll get to it. But first, why this happened.

"DevOps is dead" is a clickbait phrase doing a real job

Let me be precise, because the phrase gets thrown around lazily.

DevOps the culture, devs and ops sharing ownership instead of throwing builds over a wall, is not dead. It won. So completely that nobody argues about it anymore.

What's dying is DevOps as a job title and a team. The thing where a company posts a "DevOps Engineer" req, hires one person, and quietly means "please make our infrastructure stop being on fire." That role was always a contradiction. DevOps was supposed to be a way of working, and we turned it into a person you could hire so everyone else could keep ignoring operations.

That didn't scale. And the reason it didn't scale has a name: Kubernetes.

Kubernetes won, and that's exactly the problem

CNCF's 2024 survey put Kubernetes in production at 80% of organizations, up from 66% the year before. 93% of respondents use it, are piloting it, or are evaluating it. Adoption is basically over. Kubernetes won.

Here's the catch nobody priced in. The top blockers in that same survey aren't technical adoption. They're culture (47%), lack of training (36%), and complexity (34%). CNCF's own summary said it plainly: adoption is no longer the issue, maturity and training are.

Think about what "shift left" actually did. We told every product developer: you build it, you run it. Here's your Dockerfile, your Helm chart, your Terraform module, your Argo CD app, your alerting rules. Good luck.

We didn't shift left. We dumped a decade of operations toil onto people who were hired to write product features, and then acted surprised when they got slow and miserable. GitLab's 2025 Global DevSecOps survey found organizations lose about 7 hours per team member per week to inefficiencies like fragmented tooling and poor knowledge sharing. That's most of a working day, every week, gone.

Platform engineering is the correction. Platform engineering is a discipline where a dedicated team builds an internal developer platform that other engineers consume as a self-service product. Instead of shifting operations left onto every developer, you shift it down into a platform that a small team owns and everyone else consumes. The product developer gets a paved road. The platform team gets to be the operations experts again, except now they build the road instead of carrying every car down it.

The job is converging from infrastructure to code

This is the part that matters if operations is your career.

The old ops job was mostly operating things. SSH in, check the logs, restart the service, resize the volume, click through the console, file the ticket. The work was infrastructure, and the infrastructure was a place you went.

The platform engineering job is mostly building things. You write the Terraform or Crossplane that provisions infrastructure. You write the Argo CD config that delivers it. You write the internal CLI, the service catalog, the golden-path template, the Backstage plugin. Your output is a product with users, and your users are other engineers.

The CNCF Argo CD survey from 2025 makes this concrete: platform engineers are now 37% of Argo CD users, the single largest group. GitOps, infrastructure defined in Git and reconciled by a controller, is the default. CNCF called it "infrastructure as code, now with operational maturity." The infrastructure didn't go away. It turned into code, and code is something you commit, review, and test.

So the skill shift is real, and it's specific:

• From console to repo. If your infrastructure changes don't go through a pull request, you're doing the 2018 job.
• From scripts to software. Bash that you run once is fine. A platform is software other people depend on. It needs tests, versioning, and a changelog.
• From tickets to interfaces. The old ops team took tickets. The platform team ships a self-service interface so the ticket never gets filed.
• From "it works on the cluster" to "it works as a product." Reliability, docs, onboarding, and a feedback loop. If developers route around your platform, you built the wrong thing.

If you're an ops person reading this, none of that should feel threatening. You already know the infrastructure. The missing piece is treating your work as software with users, and that's learnable.

Now the honest part the hype skips

Every "DevOps is dead" article I've read cheerleads. Platform engineering saves productivity, kills burnout, unlocks everything. Most of those articles are sponsored, directly or indirectly, by companies selling internal developer platforms. Worth knowing.

So let's use the one big dataset nobody's selling: Google's DORA 2024 report, 39,000-plus respondents.

DORA found that internal developer platforms do increase individual productivity, team performance, and organizational performance. Good. That's the case for platform engineering, and it's a real one.

DORA also found that platforms can decrease change throughput and decrease stability. A dedicated platform team produced about a 6% productivity gain at the team level and a negligible gain for individuals. And platform engineering follows a J-curve: things get better early, then dip in the middle, then recover once the platform matures.

That's not an argument against platform engineering. It's an argument against expecting it to be free. If you stand up a platform team and judge it after one quarter, you'll catch it at the bottom of the dip and kill it right before it pays off.

It gets worse. The 2025 State of Platform Engineering report found that around 30% of platform teams don't measure their success at all. Nearly a third of these teams are being run on faith. You can't be in a J-curve and also have no idea where you are on the curve.

So here's my honest take. Platform engineering is the right direction. The career shift is real and the data on the role is solid. But the industry is adopting the idea faster than it's earning the results, and a lot of platform teams are going to get cut in the dip because nobody set expectations or measured anything.

What to actually do if you run infrastructure

Skip the panic. The demand for people who understand operations is going up, not down. The label is changing and the medium is changing.

If I were giving one piece of advice to an ops engineer right now: start treating your infrastructure work like software today, before the job title forces you to.

Put your infrastructure in Git. Make changes go through pull requests. Write one internal tool that removes a ticket your team gets every week, and treat the developers who use it as customers whose feedback matter. Learn enough Go or Python to build, not just glue. Read the DORA report yourself instead of trusting the summary.

This is the mindset behind tools like Temps and ChainLaunch — infrastructure packaged as a self-service product instead of a pile of tickets. You don't need to build a Backstage clone on day one. You need one paved road that one team of developers actually wants to drive on.

Do that and the transition isn't a transition. It's just Tuesday, with a better title and about 20% more pay.

DevOps as a job title is on the way out. The work, owning how software gets built, shipped, and run, is more in demand than it's ever been. It just looks like writing code now.

FAQ

Is DevOps actually dead?

No, and yes. DevOps as a culture, shared ownership between development and operations, won and is now standard practice. DevOps as a standalone job title and team is being absorbed into platform engineering. The "DevOps Engineer" req is slowly being replaced by "Platform Engineer."

What's the difference between DevOps and platform engineering?

DevOps is a philosophy about how teams should work together. Platform engineering is a concrete discipline: a dedicated team builds an internal platform that other engineers consume as a self-service product. DevOps says "developers and ops should share ownership." Platform engineering is one specific, scalable way to deliver on that.

	DevOps	Platform Engineering
What it is	A culture and way of working	A concrete engineering discipline
Team structure	Often one shared "DevOps Engineer" role	A dedicated platform team with a product mandate
Deliverable	Shared ownership and practices	An internal developer platform (IDP)
Who consumes it	Everyone owns ops	Product engineers consume a self-service product
Operations model	Shifted left onto every developer	Shifted down into a platform the team owns
Primary output	Process and collaboration	Software: golden paths, CLIs, catalogs, templates

Should a DevOps engineer become a platform engineer?

For most operations-focused engineers, yes. Platform engineer roles are growing, pay roughly 20% more in the Kubernetes job market, and build directly on existing infrastructure knowledge. The main new skill is treating infrastructure work as software with real users, including tests, versioning, and a feedback loop.

Is platform engineering just a rebrand of DevOps?

Partly. The cultural goals overlap. The difference that matters is structural: platform engineering creates a dedicated team with a product mandate, instead of expecting every developer to also be an operations expert. That structural change is why the job market treats it as a distinct, better-paid role.

Does platform engineering actually improve productivity?

Google's DORA 2024 research says internal developer platforms increase individual, team, and organizational performance, but the gains are not immediate and not free. Platforms can temporarily reduce change throughput and stability, and follow a J-curve: improvement, then a dip, then recovery as the platform matures. It works, but only if the organization measures it and waits out the dip.

About the author

David Viejo is CTO at KFS and builds developer platforms and infrastructure tooling for a living. He is the creator of the Bevel Operator Fabric (the Kubernetes operator for Hyperledger Fabric under Hyperledger Labs), and is building ChainLaunch, a multi-chain deployment platform, and Temps, a mini cloud platform for shipping applications. He has spent 8+ years turning operations work into self-service software. Find him on GitHub and LinkedIn.