Ask two data engineers when a new data pipeline is finished and you may get two quite different answers. One will say it is finished when the job runs on schedule and the status page turns green. The other will say it is finished when the people who use the table can rely on it for the decision they built it for. Both answers sound reasonable over coffee. Only one of them survives the first quiet Monday morning when a dashboard looks wrong and nobody can say why.
This comparison sets the two definitions next to each other, follows one team through an awkward Wednesday, and offers a way to choose your own finish line before the first line of code is written.
Definition one: it runs
The first definition is the one most of us fall into by default, because it is easy to see. The scheduler shows success, the load completes, row counts are non-zero, and the engineer who built it moves to the next request. It has real virtues. It is fast to check, it needs no conversation with anyone, and it matches the way tooling reports status.
But it measures the plumbing, not the water. A pipeline can run perfectly and still deliver a table where one source quietly stopped sending a column, or where two upstream systems now disagree about what a customer is. The green light was truthful. It simply answered a smaller question than the one the business was asking.
Teams that adopt this definition tend to discover problems through their consumers. An analyst notices a number that looks odd, raises it, and the engineer goes looking backwards through a chain of jobs that all reported success. The pipeline was “done” for weeks and trusted for none of them.
Definition two: it can be trusted for a named purpose
The second definition begins with a person and a decision. Someone in finance wants a daily revenue table to close the month. Someone in product wants usage counts to decide what to build next. The pipeline is finished when a short list of conditions, agreed with that person, is demonstrably true about the output.
Those conditions are usually plain. Every expected source has delivered within the agreed window. Key fields are present and unique where they should be. Totals reconcile with a figure the consumer already trusts, within a tolerance they chose. Late or missing data triggers a visible flag rather than a silent gap. And a named person knows the table exists and has said, in writing, that those conditions would satisfy them.
This definition costs more up front. It needs a conversation, a few automated checks and some patience. In return, “done” means something that a non-engineer can hold you to.
A small story about a retail data team
Picture a four-person data team at a mid-sized online retailer. They are asked to build a nightly pipeline that feeds a returns table to the operations group. The first version follows definition one. It lands the data, the job is green, and the ticket closes on a Friday afternoon.
By the following Wednesday the operations lead has noticed that returns for one category never seem to appear. The engineers investigate and find that a source system had begun labelling that category differently, so a filter in the transformation quietly dropped it. Every run since Friday had succeeded. Nobody had lied. Nobody had known.
The team’s reaction was not to blame the filter. They sat down with the operations lead and asked one question: which of your doubts would need to disappear before you could stop re-checking this table yourself? The answers became the finish line. Every category in the source must appear in the output or be listed as excluded with a reason. Daily totals must reconcile with the warehouse’s own return log to a tolerance agreed together. A late load must mark the table as stale. The lead would sign off in the ticket before closure.
Building those checks took about as long as the original pipeline, which surprised everyone slightly. But the Friday-afternoon closure was gone. Tickets now closed when the conditions held, which sometimes meant a Tuesday and sometimes meant a longer wait, and the operations group stopped keeping a private spreadsheet to double check the numbers.
Side by side
The contrast is easier to see in a short list of what each definition optimises for.
- Speed of closure: “it runs” wins on the day; “it can be trusted” wins over the following month, because fewer tickets come back.
- Who judges: “it runs” lets the builder judge alone; “it can be trusted” invites the consumer in.
- What gets tested: the first tests that jobs complete; the second tests properties of the data itself.
- How failure shows up: the first surfaces failures through complaints; the second surfaces them as flags before anyone has to complain.
- Cost of the next change: with explicit conditions, a later edit can be checked against the same list, so changes feel safer.
Neither definition is wrong in every situation. A throwaway analysis feeding one person’s afternoon curiosity can reasonably stop at “it ran”. The trouble starts when that casual standard quietly carries over to a table that other people depend on.
Borrowing the finish line from tools you already use
Nobody has to design these checks from a blank page. If your team already builds models with a transformation framework, the tests that framework supports are a natural home for the conditions. A walkthrough such as this guide to handling data transformations with dbt inside DataOps pipelines shows where uniqueness, completeness and relationship checks fit into the build. And once the pipeline is live, the ongoing side of trust is covered by the thinking in the beginner material on keeping a watch on pipelines. The finish line is the moment you hand over; monitoring is how you notice if the handover stops being true.
It is also worth remembering that the idea is not unique to data. Browse a blog-style site like WarOpsX, with its operations-flavoured posts, and you see how a single word such as “operations” stretches across very different kinds of work. In every one, a job without a stated end drifts.
How to choose between them
A simple rule works for most teams: if anyone other than the builder will use the output to decide something, use the second definition. Write it before you build, in a form short enough to paste into the ticket. Four or five conditions are plenty.
- Name the consumer and the decision the table supports.
- Ask them which doubts make them re-check the numbers by hand today.
- Turn each answer into a check that can run automatically, or a short manual step with an owner.
- Decide what the table should do when a check fails: flag, hold back, or fall back to yesterday’s data.
- Get a yes from the consumer on the final list, then build.
What changes in the daily rhythm
Moving from the first definition to the second changes the way a team speaks. Standups stop containing the phrase “it’s basically done”. Estimates include the time to write checks. Reviews begin with the question “what does done look like here?” instead of “does it work?”. These are tiny changes of language, yet each one turns the work toward an outcome that somebody else can verify. Over a quarter, the accumulated effect is a team that spends less time re-explaining its own output and more time building the next thing.
Teams also find that a clear finish line makes saying no easier. When a request arrives mid-build to add a new source or another breakdown, the engineer can ask whether it changes the agreed conditions. If it does, it becomes a new ticket with its own sentence of done. If it does not, it can wait. Scope stays small because stopping is defined, not because anyone is being difficult.
A last practical tip: keep the conditions next to the pipeline’s code or documentation, not in a chat thread. Six months later, a new engineer inheriting the table should be able to read what done meant, see which checks enforce it and understand who agreed to it.
Closing thought
A green status light is a fact about a job. Trust is a fact about data, and it belongs to the people who rely on it. When you define “finished” in terms of the second, you are promising something harder and far more useful. The retail team in our story did not become faster or slower overall. They became a team whose finished work stayed finished, and that is a quieter, more valuable kind of speed.