Your teams ship features faster than your platform can support them. Releases wait for the one engineer who knows the cluster, every new service starts with a copied pipeline, and the question lands on someone's desk: hire more DevOps engineers, or build a platform?

Most comparisons of platform engineering vs DevOps answer with two definitions, and definitions do not help you decide. This article gives decision criteria instead: what each approach is for, where DevOps practice stops scaling, and how the two compare by team size. It also gives two things most comparisons leave out: a checklist of signals you can verify this week, and an honest case where DevOps is enough and a platform would be overhead. We deliver platform engineering and Kubernetes services to teams on both sides of that line, and the criteria come from that work.

The short answer

DevOps is a set of practices that joins development and operations through shared ownership, automation and fast feedback. Platform engineering turns those practices into an internal product, an internal developer platform, that teams use through self-service. DevOps is how you work. A platform is what makes that way of working repeatable at scale.

What DevOps was meant to solve

Before DevOps, developers wrote code and handed it to an operations team that had to run it. Releases were rare and risky, and each side optimised for its own goal: change on one side, stability on the other.

DevOps answered with three ideas that still hold. Shared ownership: the team that builds a service also cares how it runs. Automation: builds, tests and deployments run through pipelines instead of runbooks. Short feedback loops: small changes shipped often, so problems surface while they are still cheap to fix. DORA measures how well teams do this through delivery metrics such as deployment frequency, lead time for changes, change fail rate and time to restore service.

None of this has gone out of date. In a team of ten engineers working on one product, DevOps practice carried by two or three people who care about delivery is often all you need. The trouble starts when the same practice has to stretch across many teams.

Where DevOps stops scaling

DevOps rarely fails outright. It stops scaling, and the symptoms look like people problems long before anyone sees them as a system problem.

Key-person dependency

Knowledge of the pipeline and the cluster lives in two heads. Everything works while those two people are around. Then one of them is away during a release, the deploy job fails on a step nobody else understands, and the release waits a day for them to come back. Infrastructure that lives in a few people's heads is a business risk, and it stays invisible until it costs you a release.

Reinventing the wheel

Each team builds its own Dockerfile, its own deploy job, its own health probes. They start as copies of each other and drift apart within months. The cost shows up twice. In review, because every pipeline is slightly different and has to be read from scratch. In incidents, because the same mistake is fixed in one repository and survives in five others. We described one version of this, generated manifests full of patterns nobody chose on purpose, in our post on AI-reviewed manifests.

The innovation tax

Every hour spent keeping delivery alive is an hour not spent on the product. We will not put a percentage on it, because it varies too much between teams. Ask your own team a simpler question: in the last month, how many working days went to pipelines, clusters and environments rather than to features customers asked for? If nobody can answer, that is an answer too.

An existing platform

Many teams already have a platform, whether or not they call it one: shared Helm charts, a pipeline template, a wiki page of conventions. According to the 2025 DORA research, 90% of organisations have adopted internal platforms and 76% maintain dedicated platform teams (InfoQ on DORA 2025). The CNCF platform engineering maturity model describes where most of them start: capabilities created out of need and maintained by temporary or volunteer staff, without planned central funding. A platform without an owner and a roadmap has the same problems as DevOps without a platform. Ownership is what platform engineering adds, and that is where the next section starts.

What platform engineering adds

Platform as a product

Platform engineering treats the shared delivery layer as a product. Its users are your developers, its roadmap comes from their friction, and its success is measured by how many teams choose to use it. The CNCF platforms white paper says platform teams must treat their platforms like products and develop them together with users, and that an essential goal of a platform is to reduce the cognitive load on product teams.

Team Topologies gives the organisational shape. A platform team creates services that accelerate stream-aligned teams by removing complexity, and the two interact mostly in an "X-as-a-Service" mode with little ongoing contact. Gartner describes the same idea from the buyer's side: platform engineering reduces cognitive load for developers by offering underlying capabilities through internal developer portals and platforms (Gartner).

Golden paths

A golden path is the default, supported way to ship a service. It is opinionated on purpose, so teams can follow it without reading the whole platform. Two examples from our own paths. Schema migrations run as a PreSync hook Job before new code rolls out, and data migrations as a PostSync Job after it, as we explain in our post on hook-based migrations. Readiness is owned by the application: the service reports when it can take traffic, and the platform reads that answer.

Neither rule is new. Writing them into the default path means no team has to rediscover them. How to keep a path attractive enough that teams stay on it is the subject of Designing a Golden Path That Developers Actually Use.

Self-service

Self-service is the test of a platform: what can a developer do without opening a ticket? On a working platform the answer covers the routine cases:

  • A new service from a template, with repository, pipeline and deployment generated together.

  • A preview environment for a pull request. For Greenstep, every change request gets its own full copy of the platform in about 15 minutes (case study).

  • A secret, delivered through Git with Sealed Secrets instead of a message to the person with cluster access.

  • A rollout or rollback as a pull request through GitOps.

What an IDP contains

An internal developer platform (IDP) is these pieces put together so they work as one. Typically that means infrastructure as code for clusters and cloud resources, GitOps for everything that runs on Kubernetes, CI/CD built from shared templates, preview environments, and observability with metrics, logs and traces. A portal such as Backstage often sits on top as the front door, with a catalog of services and owners and templates for new ones. The CNCF white paper lists thirteen capability areas, from provisioning APIs to secret management, and few teams need all of them on day one. Our internal developer platform service starts with the ones that remove the most tickets.


Platform engineering vs DevOps: the same request as a ticket queue and as a golden path.

Platform engineering vs DevOps: side by side


DevOps

Platform engineering

Primary goal

A shorter path from commit to production through shared ownership and automation

Make that path the default for every team through self-service

Who the customer is

The product and its end users

Internal developers in product teams

Unit of work

Pipelines, scripts and fixes, often per team or per request

Platform capabilities and golden paths, built once and reused

Ownership model

Shared by everyone, often carried by a few people in practice

A platform team owns the platform as a product, with a roadmap

Success metric

Delivery metrics: deployment frequency, lead time, change fail rate, recovery time

Adoption and developer experience, on top of the same delivery metrics

Typical failure mode

Key-person dependency and copied pipelines that drift

A platform built without its users: mandated, unused or too rigid

Team of 10 engineers

Usually enough: a few shared pipelines and written conventions

Usually overhead: borrow golden-path ideas, skip the dedicated team

Team of 50 engineers

Starts to strain: repeated work and waits on a few people

Often worth assessing: a small platform team or a partner

Team of 200 engineers

Hard to keep consistent without someone owning delivery as a product

A platform team with a roadmap is the common model

The team-size rows are a rule of thumb from our work, not a law. The signals further down are a better test than headcount.

A platform also comes with no guarantee. In the DORA research, platform users reported 8% higher individual productivity and 10% higher team performance, yet throughput fell by 8% and change stability by 14%. The report points to the added machinery that changes have to pass through. A platform built for its users removes steps from that path. One built around its own architecture adds them.

When DevOps is enough

Sometimes the right answer is no platform. One product team. One or two services. A managed platform service, a PaaS or a managed container runtime, that already handles builds, deploys and scaling. In that setup a platform team would spend most of its time maintaining itself. Two or three engineers who own delivery, a single pipeline template and a written list of conventions will serve you better.

We say this plainly because it is true for many teams that ask us. The signals that flip the answer are concrete: a second or third product team, services that outgrow the managed service (custom networking, stateful workloads, compliance requirements), or the first release that waits for one person. Until then, your thinnest viable platform may be a wiki page and a template repository.

Signals you need a platform


Three or more signals mean a platform assessment is worth the time.

Signal

How to check it this week

A new service takes more than a day to reach production

Time the last new service, from empty repository to first production deploy

Deploy knowledge sits with one or two engineers

Ask who could fix a failed deploy tonight, and count the names

Every team keeps its own copy of the pipeline

Diff the CI configuration of three repositories

The same incident class repeats across teams

Group last quarter's postmortems by root cause

Preview or staging environments are scarce

Count open pull requests waiting for an environment

Upgrades wait because nobody owns them

List the Kubernetes, chart and controller versions you run against their supported versions

Routine changes go through tickets

Count last month's tickets for secrets, DNS and new namespaces

Senior engineers spend days on plumbing

Check last sprint for pipeline and cluster work done by your most senior people

Nobody can say what runs in the cluster or who owns it

Try to list every controller and its owner without opening the cluster

Releases are batched because deploys feel risky

Compare deployment frequency now with six months ago

The rule is simple. Three or more signals mean a platform assessment is worth the time. Fewer than three, and DevOps practice with better documentation is probably enough for now.

What AI-assisted coding changes

AI writes code faster. It does not fix how you ship it. When each engineer produces more changes, every step after the editor carries more load: review, build, deploy, and the incident path when something slips through. The 2025 DORA research found that nearly 90% of technology professionals now use AI in their work, and that high-quality platforms are essential enablers for scaling AI's benefits across organisations (InfoQ on DORA 2025).

We have looked at the delivery side of this before: what AI reviews miss in generated manifests, and why an AI agent should change a cluster through a pull request. The common thread is that self-service plus guardrails keeps more code safe. The golden path sets the defaults, policy checks catch what the defaults miss, and GitOps keeps every change reviewable and revertible. Without that layer, faster code generation mostly produces a longer queue in front of the same few people.

Moving from DevOps to a platform without a rewrite

You do not have to throw away what works. The move is incremental, and it follows the three stages we run with clients, with the durations published on our site.


Assess, build, evolve: the path from DevOps practice to a platform.

Assess

About 2 to 3 weeks. We map the delivery workflow from commit to production and look for key-person risks, repeated work and missing ownership. The output is a roadmap the client keeps, whether or not we build what it describes.

Build

About 8 to 10 weeks. We build the platform core on what already works: the existing cloud and the pipelines that are sound. The first golden path covers the services that change most often. The Digital Health Outcomes migration shows this stage: Docker, Terraform, EKS and Helm as a foundation, so a new deployment is a single script away.

Evolve

Ongoing. A platform that nobody maintains becomes the next legacy system. This stage covers upgrades of Kubernetes, charts and controllers, including operators such as the Postgres operator we run, more automation as teams adopt the path, and documentation that lets your team read the system without us.


Extending the DevOps team

Building a platform

Time to value

Depends on hiring and onboarding each new person

First golden path in weeks: about 2-3 to assess, 8-10 to build the core

Ownership

Knowledge accumulates in the people you hire

Knowledge lives in code, templates and runbooks

Bus factor

Grows slowly, one person at a time

Rises with every team that moves onto the golden path

Cost shape

Grows with the number of teams, because requests grow with them

Front-loaded build, then a steadier maintenance cost

FAQ

Is platform engineering replacing DevOps?

No. Platform engineering builds on DevOps. The practices stay the same: shared ownership, automation, small and frequent changes. What changes is who carries them. Instead of every team rebuilding the same pipelines, a platform team packages the practices into a product other teams use through self-service. Gartner expected 80% of large software engineering organisations to have platform teams by 2026, up from 45% in 2022, which reflects that shift rather than the end of DevOps.

What is the difference between a platform engineer and a DevOps engineer?

A DevOps engineer usually works inside or alongside one product team, building and running its pipelines and infrastructure. A platform engineer builds shared capabilities for many teams: templates, self-service workflows, golden paths and the automation behind them. The skills overlap heavily, from Kubernetes to infrastructure as code and CI/CD. The difference is the customer. A DevOps engineer serves a product. A platform engineer serves the developers who build products.

How big does a team need to be before a platform pays off?

There is no fixed number, which is why we use signals instead of headcount. As a rule of thumb, one team with one or two services rarely needs a platform, and organisations with several product teams usually feel the strain first, in waits and repeated work. If three or more of the signals in the checklist above are true for you, a platform assessment is worth the time.

Do we need Kubernetes before we build an internal developer platform?

No. A platform is a product for developers, and it can sit on a PaaS, serverless services or virtual machines. Kubernetes is common under internal developer platforms because it gives one consistent API for running workloads, and GitOps tooling builds on it. If you already run Kubernetes, a platform makes it easier to use. If you do not, start from your delivery pain and choose the runtime after.

What is an internal developer platform in plain words?

An internal developer platform is the set of tools and paved roads a company builds so its developers can ship without waiting for anyone. In practice that means templates for new services, pipelines that already work, environments on demand, secrets and configuration handled the same way everywhere, and dashboards that show how services behave. A good one feels like a product: documented, supported and improved based on what its users ask for.

Next step

If you are not sure which side of the line you are on, a Platform Assessment will tell you in two to three weeks and leave you with a roadmap either way. To see what else we build, start with our platform engineering and Kubernetes services.

Oleksandr Simonov

Founder and CEO @ Amoniac OÜ

Working with Linux since 1998. I've seen every layer of the stack break in every possible way — so when you describe your problem, I usually know where to look before the call even starts.

Oleksandr Simonov

Founder and CEO @ Amoniac OÜ

Working with Linux since 1998. I've seen every layer of the stack break in every possible way — so when you describe your problem, I usually know where to look before the call even starts.

Oleksandr Simonov

Founder and CEO @ Amoniac OÜ

Working with Linux since 1998. I've seen every layer of the stack break in every possible way — so when you describe your problem, I usually know where to look before the call even starts.

SHARE ON SOCIAL MEDIA

Start with a focused platform assessment

Our first engagement is a paid technical assessment. We map your delivery workflow, infrastructure gaps, platform debt, and implementation priorities before anything is built.

This is a paid first engagement, designed to produce a roadmap your team can act on.