skip to content

What is the Definition of Done in Scrum, and who owns it?

level: juniorimportance: must knowfreq 78%

answer

  1. A shared promise about quality
  2. Applies to everything, not one item
  3. Makes the Increment genuinely inspectable
  4. Who writes it, who may only strengthen it

basics

~20 s

The Definition of Done is one shared quality standard that all work must meet before it counts as finished. The Scrum Team creates it; where the organisation sets a minimum standard, the team may only strengthen it, never weaken it.

solid answer

~50 s

The **Definition of Done** is the Scrum Team's explicit statement of the condition every piece of work must be in before anyone calls it finished — typically reviewed by a second developer, agreed automated checks passing, documentation updated, deployed somewhere shared. It is **one standard for the whole product**, not a list written per item: it answers *is this releasable?*, so it is written once and applied unchanged to everything. The Scrum Team creates and maintains it; where the wider organisation defines a minimum standard, the team must meet that and may make its own stricter. Its job is transparency — when everyone means the same thing by finished, the Increment is genuinely inspectable and there is no hidden remainder. Anything the team cannot yet do belongs in a visible plan to raise the standard, not in a quiet exception.

code

pseudocode · 8 lines
pseudocode
DEFINITION OF DONE  (applies to every item, every Sprint)

[ ] Reviewed and approved by a developer other than the author
[ ] Agreed automated checks pass on the integrated codebase
[ ] User-facing changes meet the team accessibility rules
[ ] New behaviour is observable in the running system
[ ] Reader-facing documentation updated
[ ] Deployed to the shared environment and usable there

go deeper

for a junior

Be ready to define the Definition of Done in one sentence and to say that it applies to every item rather than being written per item. Know that the team, not a manager, owns it.

for a middle

Explain what makes a line verifiable, and why a short standard that always holds beats a long one honoured occasionally. Expect to be asked to name six realistic lines on the spot.

for a senior

Show how you keep the standard real in practice: how you verify it was met rather than asserted, and how you defend it when a date is at risk and someone offers to drop a line.

for a principal

Own the organisational angle: when a minimum standard should be set above the team, what that costs in team autonomy, and how you avoid a standard the people doing the work have never believed in.

The **Definition of Done** is one explicit, shared statement of the quality that every piece of work must reach before the Scrum Team will call it finished and count it as part of the Increment. It describes not *what* was built but *how well* anything built here is finished. Because it belongs to the product and the team rather than to any one item, it is written once and then applied unchanged to everything. ## Why the framework needs one Scrum runs on transparency: its inspect-and-adapt loops only work when what people inspect is real. Without a written standard, *finished* is an opinion. One person means the code compiles and the happy path works; another means a stakeholder could rely on it tomorrow. A team can then report six finished items that nobody is willing to release, and nobody has lied — they simply used one word for six different amounts of work. Making the standard explicit fixes three things at once: - **A shared vocabulary.** Everyone reading an item's status reads the same list of conditions behind it. - **Trustworthy progress.** Only work that meets the standard counts, so the reported amount of finished work is the amount that is genuinely usable. - **A defence against pressure.** The standard is agreed calmly in advance, which makes it much harder to discard on the afternoon before a demonstration. ## What belongs in it The standard carries the quality activity that must hold for *all* work, whatever the item happens to do. Common lines: 1. The change has been reviewed by a developer other than its author. 2. The automated checks the team agreed pass on the integrated codebase. 3. Anything user-facing meets the team's accessibility rules. 4. The new behaviour is observable in the running system. 5. Documentation a future reader depends on has been updated. 6. The change is deployed to the shared environment and is usable there. Two properties matter more than the exact lines. First, each line must be **verifiable**: a reader must be able to check it without interviewing the author. *The code is clean* is not a standard; *reviewed and approved by a second developer* is. Second, the list must be **short enough to hold every time**. A long aspirational list honoured on a good week is worse than a short list that always holds, because the long one teaches everyone that the standard is negotiable. This is also why quality activity belongs **inside** the standard rather than being remembered item by item. An activity written into the standard is done by default and skipping it is a visible decision; the same activity left to good intentions is dropped first, and dropped hardest, exactly when a date is close. ## Who owns it The Scrum Team creates and maintains the standard for its product. Where the wider organisation defines a minimum standard — common when several teams contribute to one product, or where regulation applies — every team must meet at least that minimum and may make its own standard stricter, never weaker. The Developers are the people required to conform to it as they work. The Product Owner does not get to waive it for a favoured item, and a manager outside the team does not get to lower it for a date. That ownership is the part most often got wrong. A standard imposed from outside and never discussed by the people who must meet it becomes theatre. A standard the team writes, uses and revises is a working agreement they will defend. ## One standard, not one per item The most common confusion is between this team-wide standard and the conditions attached to a single item. They answer different questions, and both must hold: | | Definition of Done | Acceptance criteria | |---|---|---| | Scope | The whole product; every item | One item | | Question answered | Is it built well enough to release? | Is this the behaviour we asked for? | | Lifetime | Stable; revised deliberately | Written and retired with the item | | Varies per item | No | Yes | If a condition would sensibly apply to the next twenty items too, it belongs in the standard. If it only makes sense for this one, it belongs with the item. ## How teams get it wrong - **The decorative list.** Written at an away-day, pinned somewhere, never consulted. Test it by asking a developer, without warning, to name three lines. - **The negotiated exception.** *Finished apart from the checks* is a phrase that quietly redefines the word for everyone who hears it. - **The shrinking standard.** Under a deadline, lines are dropped instead of scope. The date is met and the remainder is invisible. - **The unowned standard.** A quality group writes it, the team has never read it, and nothing about the work changes. The signal an interviewer listens for is whether you treat the standard as process paperwork or as the mechanism that makes everything else in the framework mean something. It is the second: it converts a pile of claims into work somebody could actually release.

  • Can a Scrum Team weaken its Definition of Done to get more items finished in a Sprint?
    No. Weakening it does not remove work, it hides it: the finished count rises while releasability falls. The team may change the standard deliberately, but the honest lever under time pressure is scope — finish fewer items to the same standard. Where the organisation sets a minimum, the team cannot go below it at all.
  • Should two items in the same product ever be finished against different standards?
    No. One product, one standard is the whole point: it is what makes the finished count comparable and the work inspectable. Item-specific conditions belong with the item, not in a second standard. If part of the product genuinely cannot meet a line, that gap is a stated, visible exception with an owner, not a quiet parallel standard.
  • How would you tell from the outside whether a team's Definition of Done is real or decorative?
    Ask two developers separately to name three lines from memory. Then take three items marked finished last Sprint and check each line yourself. A real standard is remembered and survives that check; a decorative one lives on a page nobody has opened since it was written.

It is the outbound inspection every unit passes before it leaves the factory, whatever the customer happened to order.

saying these in an interview costs you the question

  • Says the Definition of Done is written fresh for each backlog item
  • Claims a manager or Product Owner can waive the standard for a date
  • Treats the standard as advice the team may skip when time is short
  • Believes only testers are accountable for meeting the standard
  • Confuses meeting the standard with a card reaching a column named done