"Done" in most sprint reviews means code merged and tests green — not that a real user has touched the feature in production and gotten value from it. A trustworthy Definition of Done treats "done" as a claim about verified, live outcomes, not a status a ticket earns by clearing a column. Close that gap and rework drops.

Quick Answer: A Definition of Done that only covers code and tests produces "watermelon done" — green on the board, red in production. Layer your DoD across story, feature, and release, and require live verification, not just merge status, before anything counts as done.

The Watermelon Done Problem: Why "Done" on the Board Doesn't Mean Shipped

"Watermelon done" describes a ticket that shows green — merged, tested, closed — while the feature underneath is red: broken in production, unused by customers, or quietly reverted. The board reports progress; the business reports none. The mismatch happens because most teams define "done" as an engineering checkpoint, not a business outcome.

The term borrows from "watermelon" status reports, project-management shorthand agile coaches and PMI-aligned practitioners have used for years to describe dashboards that look green from a distance but are red once you cut into them. Applied to a Definition of Done, the pattern is identical: a story clears criteria written to be easy to satisfy — code reviewed, unit tests passing, ticket linked to a PR — while nobody checks whether the feature reached a real user, held up under load, or moved the metric it was built to move.

This is a definition problem more than a discipline problem. The original Scrum Guide, authored by Ken Schwaber and Jeff Sutherland, treats the Definition of Done as a formal, team-owned artifact precisely because ambiguity there is where quality erodes — without one explicit, shared DoD, a story is "done" by five different standards depending on who you ask. Most teams write a DoD once, early, and never revisit it as the product — and its risk profile — matures.

The gap shows up downstream. Research often cited from the Standish Group's long-running CHAOS studies suggests a meaningful share of shipped features go rarely or never used by customers — a signal that "shipped" and "validated as valuable" are two different finish lines, even when the board says both were crossed.

Sprint reviews reinforce the illusion rather than catch it. Leadership sees a burndown chart trending toward zero and a demo of the happy path, and neither one asks the question that would surface the risk: has anyone outside the team confirmed this works under real conditions? The ritual is built to show completed work, not to interrogate whether "completed" was defined honestly in the first place.

Common signs your Definition of Done is watermelon-shaped:

  • A story is marked done, but nobody can say which customers have used it.
  • QA passes locally, with no check for how the feature behaves under real traffic.
  • "Done" happens before deploy, and deploy happens before anyone monitors the result.
  • Acceptance criteria describe what the code does, not what the user experiences.
  • Technical debt taken on to "make the sprint" never gets a ticket of its own.

The Mental Shift: Done Means Value Is Live and Verified — Not Code Merged

The fix isn't a longer checklist; it's redefining the finish line itself. Done should mean the change is deployed, observable in production, and confirmed to do what it was meant to do — not that a pull request merged cleanly. That shift moves ownership past the code-complete moment into the outcome the code was built to produce.

Jez Humble and Dave Farley made this argument systematically in Continuous Delivery, their influential book on release engineering: a change isn't done until it has gone through a pipeline that proves it's releasable, and ideally has been released. Their point wasn't about tooling — it was that "done" is meaningless until it's tested against the one environment that actually matters, production.

The DORA research program, associated with Dr. Nicole Forsgren, Jez Humble, and Gene Kim and later published as Accelerate, built years of study around exactly this gap. Its core metrics — deployment frequency, lead time for changes, and change failure rate — are all downstream measures of whether "done" work survives contact with real usage. A team can hit every sprint's story-point target and still carry a high change failure rate, which is the metric equivalent of watermelon done.

Making that shift concrete means moving verification earlier and ownership later:

  1. Define "value" before you define "done." Anchor acceptance criteria to a customer outcome, not a technical task — the same outcome-first framing behind jobs-to-be-done thinking (see our jobs-to-be-done complete guide for how to state outcomes precisely).
  2. Extend the DoD past deploy. Add a line for "monitored in production for N days" or "confirmed via analytics that the intended behavior occurred."
  3. Separate discovery-done from delivery-done. A validated idea and a shipped feature are different milestones — the same distinction covered in our guide to balancing dual-track agile discovery and delivery.
  4. Make "done" falsifiable. If nobody can point to evidence the criteria were met, it isn't a criterion — it's a hope.

A useful gut check: would you let a customer read your Definition of Done as a promise? If a plain-language version of a "done" feature would overstate what's actually true today, the DoD is lying — to the team, and eventually to the customer.

The only Definition of Done worth keeping is one a customer could read as an honest promise. Anything looser is internal theater dressed as rigor.

A Layered Definition of Done: Story, Feature, and Release

A single, flat DoD applied to every unit of work is part of the problem — a login button and a payments migration shouldn't clear the same three checkboxes. A layered DoD sets separate, cumulative criteria at the story, feature, and release levels, so small work stays fast while larger, riskier work picks up the extra verification it actually needs.

LayerWhat it coversTypical criteriaWho verifies
StoryA single unit of work (one ticket)Code reviewed, automated tests passing, acceptance criteria met, merged to mainEngineer + reviewer
FeatureA user-facing capability made of multiple storiesDeployed to production, feature flag validated, works across target devices, documented, support briefedPM + tech lead
ReleaseA shippable increment bundling one or more featuresMonitored in production, rollback plan tested, success metric instrumented and behaving as expected, stakeholders notifiedPM + release owner

Layers should be cumulative, not parallel: a feature can't be done if its component stories aren't, and a release can't be done if its features haven't cleared their own bar. Skipping a layer — usually the release layer, since nobody "owns" it by default — is the most common way a weak DoD sneaks back in even on teams with a well-written checklist.

Picture a payments migration built across six stories. Each story clears its own DoD — reviewed, tested, merged — over two sprints, and the burndown chart looks clean the entire time. But if nobody checks the feature-layer criteria (does the new flow work across the card processors currently in production, not just the sandbox?) or the release-layer criteria (is there a rollback path if the processor rejects a transaction type nobody tested?), "done" at the story level is quietly carrying risk that only shows up once real transactions hit it.

Layering only works if someone owns each tier's sign-off, and in many organizations that ownership blurs between the product manager and the product owner. Clarifying where PM and PO responsibilities actually diverge prevents the release layer from becoming nobody's job — the most common reason "feature done" quietly turns into the last checkpoint anyone enforces. If you can't turn a feature off quickly once it's live, it isn't done at the release layer, regardless of what the story and feature layers already cleared.

The Hidden Costs of a Weak Definition of Done

A DoD that's too easy to satisfy doesn't remove work — it just moves the work later and hides it. Weak DoDs show up as rework sprints, undetected technical debt, inflated velocity, and eroding trust between product and engineering: costs that rarely appear on the board that created them.

Hidden costHow it shows upWhy the board doesn't show it
ReworkThe "done" feature returns as a bug ticket, a support escalation, or a follow-up story next sprintRework gets counted as new work, not as the original story failing its DoD
Undetected technical debtShortcuts taken to hit a deadline — skipped tests, hardcoded config, no monitoring — never get their own backlog itemWard Cunningham's original technical-debt metaphor described a deliberate loan; most weak-DoD debt is taken without anyone agreeing to the terms
Inflated velocityStory points get claimed for work that isn't actually usable yetVelocity tracks ticket throughput, not delivered value — the same gap covered in our critique of velocity vs. value in story points
Trust erosionStakeholders stop believing sprint reports; leadership starts asking for a separate "real" status updateOnce a few "done" features turn out not to be, every future "done" gets discounted

None of these costs are visible in a sprint review, which is exactly the trap. A burndown chart tracks tickets crossing into "Done" — it has no column for "came back three weeks later as an escalation." A team that doesn't track its own rework rate is, in effect, choosing not to measure its DoD's failure rate.

The DORA research referenced above is useful here precisely because change failure rate is one of the few widely adopted metrics that measures this gap directly rather than measuring output. Elite-performing teams, by DORA's published bands, keep that rate low while still deploying frequently — evidence that speed and a strict definition of "actually done" are not in tension, whatever the watermelon-done instinct assumes. Slow, careful, and reliable are not synonyms; a team can be fast and honest about what "done" means at the same time.

Building a Definition of Done Checklist That Actually Holds

A DoD checklist earns trust when it's specific, layered, testable, and revisited — not when it's long. Five practices turn a checklist that gets rubber-stamped into one that changes behavior, and none of them require new tooling to start.

  1. Write criteria as evidence, not intentions. Replace "properly tested" with "unit tests pass in CI and a manual smoke test ran against staging with the feature flag on." Vague verbs are where watermelon done hides.
  2. Split the DoD into story, feature, and release tiers (from the table above) and place each tier where the relevant sign-off actually happens — story tier in the PR template, release tier in the release checklist.
  3. Add a post-deploy verification line to every tier above story. "Confirmed via dashboard that [metric] moved as expected within N days" turns "done" into a claim that gets checked, not assumed.
  4. Run a DoD retro after every incident that the checklist should have caught. A recurring failure mode is feedback about the checklist, not just a one-off bug — fix the criteria, not only the code.
  5. Anchor acceptance criteria to the customer journey, not just the transaction. A checkout button that "works" in isolation can still fail the customer if it breaks the flow around it — mapping criteria against a customer journey catches gaps a functional test alone won't.

For the fuller picture of how a Definition of Done fits into sprint cadence, ceremonies, and delivery flow more broadly, our complete guide to agile delivery walks through the surrounding practices this checklist plugs into.

Making "Done" a Shared Reference, Not a Debate

Most Definition of Done disagreements aren't really about quality standards — they're two people picturing different acceptance criteria for the same ticket and discovering the mismatch at review time, when it's expensive to fix. A living spec that both sides can point to during hand-off closes that gap earlier.

This is the problem Prodinja's Spec Studio is built around. Its acceptance-oriented spec sections are designed to give product and engineering a single, versioned reference for what "done" must satisfy — story-level acceptance criteria sit inside the same document as the feature's intent, so a reviewer isn't reconciling a PRD against a separate DoD against a separate PR description.

Because Spec Studio tracks changes with PR-style diffs and readiness gates, a spec can't move to hand-off export until the sections a team has marked as required for done are actually filled in. That's a structural nudge toward the layered checklist above — story, feature, and release acceptance criteria living in one place a team actually reads.

It isn't a claim that software can verify quality for you. The verification still has to happen; the point is that the record of what "done" was supposed to mean doesn't quietly go missing between the spec, the pull request, and the release notes.

Key Takeaways

  • "Done" and "shipped" are different claims. Code merged, tests green, and a closed ticket only prove engineering finished its part — not that a customer got value from it in production.
  • Watermelon done hides in checklists that are easy to satisfy. If nobody checks a criterion, it isn't a criterion — it's an aspiration dressed as a checklist.
  • A layered DoD — story, feature, release — matches verification effort to risk, instead of applying one flat checklist to work of wildly different size and blast radius.
  • Weak DoDs don't remove work, they defer and disguise it — as rework tickets, undocumented technical debt, inflated velocity, and eventually distrust between product and engineering.
  • Post-deploy verification is the missing tier in most teams' DoD. Add a line that requires confirming production behavior, not just deployment.
  • Revisit your DoD after every incident it should have caught. A recurring failure mode is feedback about the checklist itself, not just about the code.
  • A shared, specific spec reduces DoD arguments before they start — the earlier product and engineering agree on what "done" must show, the less it gets renegotiated at review time.

Frequently Asked Questions

What is the difference between "done" and "shipped" in agile?

"Done" typically means a story cleared its team-agreed criteria — usually code merged and tested. "Shipped" means the change is live in production and available to real users. A story can be done without being shipped, and — more dangerously — marked done while quietly broken once it ships.

What should a good Definition of Done checklist include?

A strong Definition of Done checklist separates criteria by layer — story, feature, and release — and states each one as evidence that can be checked, not an intention. At minimum it should cover code review, automated tests, deployment, and a step confirming the feature behaves as intended in production.

Why do teams keep a weak Definition of Done even when it causes problems?

Because a strict DoD looks like it slows the team down in the short term — sprints report lower throughput once "done" requires evidence instead of intention. The cost of a weak DoD shows up later and gets attributed to other causes, so the checklist itself rarely gets blamed for the outcome.

How is Definition of Done different from Definition of Ready?

Definition of Ready gates when work can start — confirming a story has enough clarity, sizing, and resolved dependencies to enter a sprint. Definition of Done gates when work can be considered finished. Teams that only define one of the two usually end up with vague starts, vague finishes, or both.

How often should a team update its Definition of Done?

Review it after any production incident the checklist should have caught, and again whenever the product's risk profile changes — a new compliance requirement, a new integration, or a move into a higher-stakes customer segment all justify a revisit. Outside those triggers, a quarterly review is a reasonable minimum cadence.