How the Meaning of ‘Done’ Is Changing in DevOps Teams

How the Meaning of ‘Done’ Is Changing in DevOps Teams

Sit in on a DevOps team’s planning meeting today, then imagine the same meeting from a decade or so earlier, and the most striking difference is not the tooling. It is the way people talk about the word “done.” Where it once meant “the developer thinks it works,” it now tends to mean “the thing is running, observed and understood by the people who will live with it.” This article traces how that definition has been changing, what the current direction looks like, and what students and early-career engineers should take from the trend.

A note on method: these are observations of common practice as it is widely discussed in the field, not figures from a survey. Teams differ enormously, and plenty of them still work the older way. Read the trends below as a rough compass bearing, not a measurement.

Where the story starts: the throw-it-over-the-wall era

In the older pattern, development and operations lived in separate rooms, and “done” was the moment code crossed a boundary. Developers declared victory when features passed their own tests. Operations discovered the real behaviour of the system at the hours when nobody wanted a surprise. The famous phrase “it works on my machine” was a joke precisely because it described a genuine gap in what each side counted as finished.

The gap produced a particular kind of friction. Releases arrived with long notes, defects surfaced late, and the people who had to answer the pager were rarely the people who understood the change. Much of the early DevOps movement can be read as an attempt to close that gap by making the definition of done a shared artefact instead of a private belief.

Trend one: done now includes running it

The clearest shift is that finishing is increasingly measured in production, not merely in a test environment. Teams that follow the “you build it, you run it” idea fold operability into the definition: the change is visible in monitoring, there is a place where its errors would show up, and someone on the team knows how to respond when it misbehaves. A feature that nobody can observe is regarded as unfinished, however elegant its code.

For a student, this means that a project is more convincing when it includes some evidence of life after deployment, such as a simple dashboard or a log you can show. Hiring managers read that as a sign that you understand what the job really involves.

Trend two: criteria written where the work lives

A second movement is geography. Acceptance criteria used to sit in a separate document that few people reopened. Increasingly they live in the ticket itself, in the pull request template and, for some checks, in the pipeline as automated tests. The location matters because people follow the path of least resistance: criteria placed next to the work get read, and criteria stored elsewhere get forgotten.

The healthy version of this trend keeps a human sentence at the top, describing the intended end state, and lets automation confirm the parts that can be confirmed mechanically. The unhealthy version replaces thought with a wall of green ticks that nobody understands. The difference between the two is whether the team can still say, in plain language, what finished means.

Trend three: smaller slices, sharper endings

Teams that deploy frequently have discovered that small changes are easier to define as finished. A giant project can drift for months, but a change that fits inside a few days has a natural boundary. The habit of shipping thin slices makes the finish line almost self-evident, since the question shifts from “is the whole platform done?” to “is this slice live and behaving?”

Students sometimes miss this because coursework often rewards large, sprawling submissions. A smarter practice project is a small system with a very explicit ending: it deploys from a single command, it exposes one health check, and its readme states what it will not do.

Trend four: more voices in the definition

The definition used to belong to whoever wrote the code. Today it is more often negotiated among developers, operations staff, security specialists and sometimes the people who use the service. Each group adds a line: security wants confirmation that a secret is not exposed, operations wants an alert to exist, the product owner wants a visible change for users. The result is richer, though it also risks bloat if nobody trims it.

The skill emerging in response is editing. The most valued engineers are those who can combine several stakeholders’ wishes into one compact sentence and explain, without friction, why some requests belong on another ticket.

Trend five: cost and risk folded into the sentence

A newer thread is that finishing increasingly mentions things that used to be afterthoughts. A change might not count as complete until its running cost is understood at a rough level, or until a quick look at its exposure has been made. This does not mean every ticket becomes a heavy review. It means a line or two has crept into typical templates, reminding the author that the system will live on after the merge and that other people will pay for its quirks.

Some teams find the added lines helpful; others feel overwhelmed. The pattern that seems to work is a very short default list, with extra lines added only where the change genuinely warrants them.

A short scene from a modern team

Picture a team on a Wednesday morning, closing out a change to a payment-reminder service. The ticket’s first line states the end state: reminders are sent through the new queue, failures appear on the shared board and the old path is switched off. A teammate who did not write the change runs through the line, confirms each part in a few minutes and moves the ticket on. Nobody makes a speech. The calm is the achievement. Ten years ago the same change might have taken a week of meetings and a long release note.

Lessons for people learning the craft

Whether you are studying or retraining, the trend rewards habits more than certificates. Practise writing a sentence of finished state for every exercise. Observe your own deployments rather than assuming they worked. Keep your projects small enough to have crisp endings. For a structured look at how organisations think about the larger picture, a piece on the skills, roadmap and strategy behind DevOps-led IT change frames why these shifts are happening. And for learners worried about what to fill in next, a practical guide to which skills a DevOps beginner is probably still missing makes a useful companion.

A glance at unrelated writing

Ideas about completion are not unique to engineering, and it can be refreshing to see them reused elsewhere. A casual example is an operations-themed blog with travel guides, rental posts and event listings, whose plain framing of everyday tasks reminds readers that clear endpoints are a universal habit. It is no technical reference, but it supports the point that this skill transfers.

Cautions about the trend

Not every shift is an improvement. Some teams have turned the definition of done into a long, ritualistic checklist that slows work without improving outcomes. Others rely so heavily on automated checks that they stop thinking about what the checks do not cover. And in some organisations, the phrase is used as a weapon: “that is not in the definition of done” becomes a way to deflect reasonable requests. The healthiest teams treat the definition as a shared working agreement that is reviewed and trimmed regularly.

Where the direction seems to be heading

If the trend continues, finishing will probably keep moving closer to real use: more attention to what happens after release, more shared ownership of the definition and more precise, smaller endings. Tooling will keep making it easier to confirm facts automatically. The human part, deciding which facts matter, is unlikely to be automated away, and it is the part worth learning.

Closing the story

The word “done” has grown up. It started as a private feeling, became a handover, and is gradually turning into a shared, observable state described in a sentence anyone can read. For teams, that means fewer unpleasant surprises. For learners, it means a straightforward habit to build now: state the finished condition before you begin, check it honestly at the end and keep the sentence short. It is a small practice, but it is increasingly the one that separates tidy engineering from endless busyness.