The phrase "DevOps" has lost most of its rhetorical force. Ten years ago it was a banner you waved to convince an organization to break down silos. In 2026 it is closer to electrical wiring — invisible when it works, catastrophic when it does not, and absolutely nobody argues whether you should have it.
What changed underneath the label is more interesting than the label itself.
Platform engineering ate the role
The biggest shift is the rise of platform engineering as the inside-the-company expression of DevOps. Instead of every dev team having a DevOps person, a central platform team builds an internal developer platform: a paved road of templates, CI pipelines, deployment targets, and observability that the rest of the company self-serves on.
This is not a renaming. The skill set is different. A platform engineer thinks about product (the developer is the user), API design (what surface do you expose to teams?), and amortizing operational work across many consumers. The "DevOps engineer plopped on a project team" model rarely scales past 5–10 services; the platform model does.
Infrastructure is finally code, mostly
Terraform, Pulumi, CDK, and Crossplane have collectively made click-ops in production something most teams are embarrassed about. The remaining holdouts are usually around (a) initial bootstrap of the cloud account itself and (b) a long tail of point-and-click services where the IaC support is thin.
The interesting fight in 2026 is not whether to use IaC but which abstraction level. Raw Terraform still wins for portability and explicitness. Higher-level wrappers (CDK, Pulumi components, Crossplane compositions) win for velocity inside a company that controls both the provider and the consumer. The wrong answer is to use one without admitting the tradeoff.
Cloud spend is now part of reliability
FinOps used to be a side conversation. Today, in any organization past the seed stage, cost is treated as a reliability concern: an over-provisioned cluster bleeds budget; an under-provisioned one bleeds availability. The discipline of right-sizing instances, killing zombie environments, and tagging every resource for chargeback is now table-stakes.
Concretely: any CI pipeline I build now has a step that fails if a Terraform plan would create resources without the standard cost-allocation tags. The cost reviewer is the same human as the security reviewer, with the same right to block.
AI is in the loop, but mostly for boring jobs
"AIOps" was oversold for years. What actually shipped is much narrower and more useful: language models that explain pod logs, autocomplete IaC, draft runbooks, and triage alerts before a human looks at them. None of this replaces the on-call engineer. It compresses the time between "something is wrong" and "you have a working hypothesis" — which is the part of incident response that scales linearly with cognitive load.
What did not change
The fundamentals are the same as they were ten years ago. Small batches deploy more safely than big ones. Feature flags let you separate "deployed" from "released". Observability is the cheapest insurance policy in software. Postmortems are blameless or they are useless. Backups are not real until you have restored from one.
If you are starting today, the temptation is to chase the new tooling. Most of the value will come from the boring fundamentals, configured properly, applied consistently. The interesting work then becomes choosing which abstractions to take on top of that base — which is exactly the work a senior platform engineer does.