DevOps Roadmap

You can turn a commit into one trustworthy, immutable, addressable build output. Everything after this level assumes the artifact is the unit that moves; if the artifact is not stable, no later practice can be. At the end of this level you can answer "what exactly would I deploy, and which commit produced it".

You can package that artifact so it runs the same way anywhere, and supply the parts that legitimately differ per environment — configuration and credentials — without rebuilding it. You stop shipping "the code" and start shipping artifact plus config, which is what actually determines behaviour.

You can put a new version in front of real traffic on purpose, in a shape you chose, and take it back. This is the level where deployment stops being an event and becomes a routine, and where you learn that the hard part is never the deploy — it is version coexistence and the way back.

The environment the artifact runs in becomes reviewable, reproducible and diffable rather than a console someone clicked. You can stand a whole environment up from a repository, see what a change will destroy before it destroys it, and detect when reality has stopped matching the code.

You can run many replicas of many services, let them find each other, and put traffic in front of them without dropping requests. Kubernetes is taught here as one implementation of the scheduling and reconciliation problem — the level is passed by understanding the problem, not by adopting the tool.

You can tell whether production is healthy without asking anybody, get woken up only for things that need a human, and run an incident from detection to mitigation to a write-up that changes the system. This is the level that turns a deployer into an operator.

You can answer how much traffic the system can take, what happens when it takes more, what it costs per unit of work, and how to change a schema without an outage. This is where reliability, money and the database stop being separate conversations.

You can answer "what is in production, where did it come from, and who approved it" with evidence rather than recollection — and you can make the safe path the easy path for other teams instead of reviewing their work by hand. This is the level where delivery becomes a product with users.

You can lose a region, a database or a dependency and still have a procedure that returns the system to service within objectives you have actually tested. At this level you are no longer keeping a service up; you are engineering the properties that let an organisation keep many of them up.