Before "Platform Engineering" was a job title, DevOps teams were already building the self-service infrastructure that now powers AI-assisted developer workflows.
In 2020, I wrote about how DevOps enables self-service delivery — the idea that developers shouldn't have to wait in a queue to get an environment, spin up a database, or trigger a deployment. The ops team's job, I argued, was to build the paved roads that developers could walk themselves.
Five years later, that idea has a name: Internal Developer Platforms (IDPs). And the teams that built self-service infrastructure early are now miles ahead — because those same platforms are the foundation on which AI-assisted developer workflows are being built.
💡 Self-service DevOps was never just about convenience. It was about reducing cognitive load, eliminating bottlenecks, and letting engineers focus on what they actually create value doing — building software.
Self-service doesn't mean "no guardrails." It means the guardrails are baked into the platform rather than enforced by a human approval process. A developer should be able to:
None of this means ops is out of the picture. It means ops built the system that makes all of it possible safely.
The foundation of self-service is treating infrastructure like software. When every environment is defined in code, developers can read it, understand it, and modify it within guardrails. Terraform modules, Helm charts, and CloudFormation templates become the building blocks that teams assemble rather than infrastructure that ops hands down.
GitOps — using Git as the single source of truth for both application and infrastructure state — is what makes self-service deployments safe. When a developer merges a PR, the pipeline takes over: build, test, scan, deploy. No human in the loop for the routine case. Humans step in for exceptions.
ArgoCD and Flux have made this pattern accessible at any scale. The developer experience is simple: push code, watch it deploy. The ops experience is: define the policy once, trust the system to enforce it.
The newest layer — and the one that's accelerating fastest — is the developer portal. Tools like Backstage (open-sourced by Spotify) give developers a single place to discover services, provision resources, view documentation, and understand ownership.
This is where self-service becomes a product. The ops team isn't just running infrastructure — they're building an internal product that developers use every day. That shift in mindset changes everything about how platform teams operate.
Here's where it gets interesting. The same self-service infrastructure that reduces friction for human developers also reduces friction for AI agents.
When an AI coding assistant (like GitHub Copilot or Claude) helps a developer write code, that code still needs to go through the same pipeline — build, test, scan, deploy. The self-service platform doesn't care whether the code was written by a human or suggested by an AI. The guardrails apply either way.
But there's a new frontier emerging: AI agents that interact with the platform directly. Imagine an agent that:
All of this is possible only if the platform exposes clean, well-defined APIs that both humans and agents can use. Self-service infrastructure isn't just for developers anymore — it's for agents too.
When teams struggle with slow delivery, the instinct is to look at the pipeline. But in my experience, the real bottleneck is almost always approval processes, unclear ownership, or lack of self-service tooling — not the pipeline itself.
A team that has to wait three days for an ops engineer to provision a dev environment will never ship fast, no matter how optimized their Dockerfile is. A team that can provision their own environment in five minutes — with security, compliance, and cost guardrails already baked in — will ship fast almost regardless of their pipeline speed.
🚀 The goal of self-service DevOps: Make the right thing easy and the wrong thing hard. Not through process — through product. Build the platform your developers deserve.
If you're building self-service infrastructure from scratch, start here: