Upgrade & Secure Your Future with DevOps, SRE, DevSecOps, MLOps!
We spend hours scrolling social media and waste money on things we forget, but won’t spend 30 minutes a day earning certifications that can change our lives.
Master in DevOps, SRE, DevSecOps & MLOps by DevOps School!
Learn from Guru Rajesh Kumar and double your salary in just one year.
Every AIOps ticket eventually gets closed. The only question is whether somebody decided it was finished or whether it simply ran out of energy. Teams that never write down their finish line tend to discover it by accident: a deadline arrives, a manager asks, or the engineer gets pulled onto the next fire. This piece compares the two most common ways of defining done, and shows why the choice matters more than the tooling you are rolling out.
The setup: a migration nobody can finish
Picture a typical request. An operations group wants its anomaly-detection models moved from an old scheduler to a new container platform. The ticket says “migrate the models.” Three weeks later, half the models are running on the new platform, a few are running on both, and nobody can say whether the work is complete because the ticket never said what complete looks like.
That drift is not a character flaw. A task with no stated end point behaves like a gas: it expands to fill whatever room is available. Each new discovery (a forgotten dependency, a dashboard still reading the old output, a nightly job with a hard-coded hostname) feels like it belongs to the original task, so scope grows quietly. Defining the finish line is the cheap fix. One sentence, written before the first command is typed, turns stopping into a decision instead of an accident.
Option one: done means the task list is empty
The first style of finish line is a checklist. You write out the steps, you work through them, and when the last box is ticked the ticket closes. For the migration above that might read: export the model artifacts, build the container image, deploy to the new platform, switch the scheduler entry, decommission the old job.
Where it works. Task-list done is excellent for routine, well-understood changes. If the team has moved a dozen models before, the steps are known, the order is stable, and the risk is low. The checklist is quick to write, easy to delegate, and easy to audit afterward. A new starter can follow it without asking anyone a question.
Where it fails. A checklist describes activity, not results. It is entirely possible to complete every step and still have a broken system, because the list encodes what you expected to need rather than what is actually true afterward. The image was built, but it pulls a stale library. The scheduler entry was switched, but the alert routing still points at the retired host. Everything on the list is ticked and the ticket is closed, yet the on-call engineer gets a confusing page two nights later.
Option two: done means a statement is true
The second style flips the question. Instead of listing what you will do, you state what will be true when you are finished, then work until you can demonstrate it. Engineers will recognise this as acceptance criteria, the same discipline used for feature tickets, applied to operations work.
For the same migration, outcome done could be written as one sentence plus a few testable lines: “Every production anomaly model runs on the new platform, produces scores that match the old output within an agreed tolerance for a full week of data, and pages through the existing on-call rota; the old scheduler entries are disabled and documented.”
Where it works. Outcome done shines when the work is unfamiliar, when several people touch it, or when the cost of a silent failure is high. It gives the whole group the same picture of the end state. It also gives you a ready-made test: either the scores match or they do not, either the page arrived or it did not. Disagreements move from opinions to observations.
Where it fails. The weakness is the writing itself. A badly worded outcome is worse than a checklist, because it creates false confidence. “The platform is stable” is not a finish line; nobody can ever prove it. Outcome statements also take longer to produce, and teams under pressure skip the thinking and fall back on vague goals. A criterion that cannot be checked by someone other than its author is wishful, not useful.
Side by side: what each style actually buys you
- Protection against scope creep. The outcome statement wins. A proposed extra either serves the sentence or it goes on a separate ticket.
- Handover quality. Outcome wins again. A stranger reading the ticket a year later can see not just what was done but what was proven.
- Risk of false completion. The checklist is the riskier option, since every step can pass while the result is wrong.
Neither style is superior in every situation. The mistake is choosing by habit rather than by the nature of the job. A useful rule of thumb: if you could do the work half asleep, a checklist is enough; if you would be nervous explaining to a colleague how you know it worked, you need an outcome statement.
The hybrid most teams end up with
In practice the strongest tickets use both. The outcome sentence sits at the top and acts as the boundary; the checklist underneath is the route you currently expect to take, and it is allowed to change as you learn. If a step turns out to be unnecessary, you drop it. If a new step is needed to make the sentence true, you add it. Anything that does not serve the sentence is deferred by default.
How to write a finish-line sentence that holds up
A sound sentence fits in one breath yet is concrete enough to be proven wrong. Some patterns that work for operations and AIOps tickets:
- Name the observable. Choose something you can look at: a log line, a dashboard panel, a ticket that stopped arriving, a job that completed on schedule. If the evidence cannot be seen, the criterion cannot be checked.
- Give it a window. “Works” at 2 p.m. proves little. “Ran cleanly through a full weekly cycle” proves much more, because weekly jobs and month-end spikes have a way of exposing what a quick test misses.
- State who consumes it. Most operations work exists to serve someone: an on-call engineer, an analyst, a finance team reading a report. Add the consumer to the sentence and you automatically include their needs, such as alert routing or output format.
- Add the cleanup clause. Many tickets fail at the tail. Include the removal of the old thing, the update of the documentation, and the closing of any temporary access, as part of the definition rather than as optional courtesy.
- Cap it. Say what is explicitly out of scope. A single line such as “metric renaming is a separate ticket” prevents a surprising amount of grief.
Recite the draft to a colleague who missed the kickoff. If they can tell you how they would test it, you are done writing. If they ask what you mean, rewrite it.
A worked comparison on a second kind of ticket
Consider a different request: connect a new data source to a correlation engine so that its events appear alongside everything else. The task-list version needs four steps and an afternoon.
The outcome version asks harder questions. Do the events carry timestamps in the zone the engine expects? Do two events describing the same incident from different sources get grouped, or does the engineer still see them twice? Can someone on the support rota find the new source in the tool without being told where to look? Answering those takes longer, but they are exactly the questions that decide whether the integration was worth doing. A team that only ran the checklist would close the ticket and learn the answers from complaints.
For teams still working out how to introduce this kind of tooling into daily routines, a separate walkthrough of introducing AIOps to a support group deals with the people side of such a rollout and sits comfortably beside this habit.
A short note on where this idea shows up elsewhere
The habit is not unique to IT. It turns up wherever work can sprawl. One blog-style website, WarOpsX, a site built around operations-themed posts, is a reminder of how broadly the word “operations” gets used; the same question of when a job is truly finished applies whether the topic is software, events or travel.
Trying it on one live ticket
No new process is required. Choose one open ticket that has been dragging. Write one sentence describing what will be true when it is complete, including who consumes the result and what gets cleaned up. Add one line for what is out of scope. Share it in the ticket and ask the requester whether it matches their expectation.
Watching infrastructure across several clouds benefits from the same thinking, as the practical write-up on AI-assisted monitoring across multiple clouds explains, and this primer on handling IT trouble in real time shows a clear end state helping during live incidents too.
The takeaway
Task-list done answers “what did we do?” Outcome done answers “what is now true?” For routine work the first is fine. For anything unfamiliar, shared, or costly to get wrong, the second is the safer choice, and the best tickets carry both. Whichever you pick, pick it deliberately, write it in one sentence, and let that sentence decide when the work stops.