✅ Definition of Done
Master the language of quality standards, "done done," and writing verifiable DoD criteria. Intermediate
0 / 45 completed
1 / 45
A junior developer asks during backlog refinement:
"What's the difference between the Definition of Done and acceptance criteria? They both seem to describe when a story is finished."
Which response correctly explains the distinction?
The Definition of Done (DoD) and acceptance criteria serve different purposes and operate at different levels:
| Concept | Scope | Who defines it | Example |
|---|---|---|---|
| Definition of Done | Every story, every sprint | The whole Scrum Team | "All unit tests passing, code reviewed, deployed to staging" |
| Acceptance criteria | This specific story only | Product Owner + team | "Given the user enters an invalid email, When they submit the form, Then an inline error is shown" |
A story is truly done only when it satisfies both its acceptance criteria (it does the right thing) and the Definition of Done (it meets the team's shared quality standard). This is why engineers say "done done" — functionally complete is not the same as DoD-compliant.
2 / 45
During the sprint review, a developer presents a feature and says:
"This one is done done. It passed all acceptance criteria, all tests are green, the code was reviewed by two people, and it's already deployed to staging."
What does the phrase "done done" specifically communicate in Scrum?
The phrase "done done" emerged in Agile teams to distinguish between two very different states:
| State | Meaning | Example |
|---|---|---|
| "Done" (first done) | Developer's personal assessment: "I finished coding it" | Feature works locally; not yet reviewed or tested |
| "Done done" | Fully satisfies the team's Definition of Done | Tests passing, reviewed, deployed to staging, documented |
The distinction matters enormously in sprint reviews. A story that is "done" but not "done done" cannot be presented as a releasable increment — it still carries hidden risk. The phrase is a team shorthand for: "I'm not just saying I finished coding; I'm saying it's genuinely ready."
3 / 45
The team is updating their Definition of Done after a retrospective. They debate which entry is correctly written as a verifiable, observable DoD criterion.
Which of the following DoD entries is correctly written?
A well-written DoD entry must be observable — anyone can check it without subjective interpretation:
| Option | Problem |
|---|---|
| A — "high quality and thoroughly tested" | Subjective: what counts as "high quality"? No measurable threshold. |
| B — "works correctly across all environments" | Vague: "works correctly" is subjective; "all environments" is undefined |
| C — "team members are satisfied" | Subjective and unmeasurable — satisfaction cannot be objectively verified |
| D — "80% branch coverage in CI report" | ✓ Specific threshold, automated measurement, named evidence source |
Each DoD entry should start with an action verb and specify an observable outcome: "Tests written and passing", "Code reviewed by at least one other developer", "Deployed to staging environment". If a criterion requires someone to make a judgement call, it will be interpreted inconsistently across team members.
4 / 45
During a retrospective, the team proposes adding "Deployed to production" as a criterion to their Definition of Done. The release manager says:
"I'd think carefully about that — it could create practical problems for how we close out stories during the sprint review."
Why might adding "Deployed to production" to the DoD create problems for this team?
Including "Deployed to production" in the DoD ties the team's ability to mark a story as done to external factors they may not control:
| Scenario | Risk |
|---|---|
| Release requires sign-off from security / compliance | Story is blocked as "not done" even though engineering is complete |
| Coordinated release with other teams required | Sprint review cannot show "done" increment; velocity is distorted |
| Release window falls outside sprint boundary | Done stories carry over across sprints, breaking sprint goal clarity |
Teams that practice continuous deployment and can safely deploy every merged PR may include this in their DoD without issue. For teams with managed or coordinated release processes, the better practice is "Deployed to staging, ready for production release" — keeping the DoD within the team's control.
5 / 45
After Sprint 22, a senior developer unilaterally adds three new items to the team's Definition of Done wiki page, saying: "I added these quality checks because I think we need them. I didn't want to wait until the next retro."
When should a Scrum Team update their Definition of Done, and what is wrong with this approach?
The Definition of Done is owned and maintained by the entire Scrum Team — not any individual member. Changes to it should follow a deliberate process:
| Correct DoD change process | Why it matters |
|---|---|
| Raise the idea during a retrospective | All team members can discuss feasibility, impact, and trade-offs |
| Team agrees collectively on the new criterion | Shared ownership — no one is surprised by new quality requirements mid-sprint |
| New criterion takes effect from the next sprint | Prevents mid-sprint disruption; team has time to adjust workflow and capacity planning |
A unilateral addition is problematic even when the intention is good: other team members may not know about it, it may affect sprint capacity (more time per story), and it erodes team trust in the shared quality agreement. The retrospective is the designated forum for this kind of improvement.
6 / 45
Sarah (Developer): "Hey team, I'm about to merge this PR. The API response shows the user profile was updated successfully, and all tests are passing. But the documentation hasn't been updated yet – should I mark this as 'done'?"This scenario highlights a common misunderstanding about the Definition of Done. Simply passing automated tests or receiving code review doesn't automatically make a story 'done'. The DoD specifies *all* conditions that must be met for a story to be considered complete – in this case, it needs documentation updates to align with the data change. Marking it as 'done' prematurely risks delivering an incomplete feature and causing rework later.
7 / 45
Liam is pointing out that the DoD, in this case, isn't just about the code being written and tested. It's about *all* the necessary steps to ensure a story is truly complete – including deployments and infrastructure changes. The common misconception is that 'done' simply means functional; however, a robust DoD clearly defines all criteria that must be met before a story can be considered finished for that sprint. This emphasizes that 'done' isn't just about the code itself, but its integration with the system.
8 / 45
During a Slack conversation about a new feature, Alex writes: 'Okay, I've pushed the code to GitLab. The build succeeded and the tests are passing. It's ready for review.' Ben replies: 'Sounds good, but is it actually *deployed* to our staging environment?' What does Ben's question reveal about the importance of a clearly defined Definition of Done (DoD)?
Ben's question highlights a crucial gap in Alex's communication. Simply stating the build succeeded and tests pass doesn't guarantee the feature meets all DoD requirements. The DoD should encompass *all* criteria needed to confirm completion – including deployment to an environment where it can be realistically tested and validated, before formally accepting the story. This prevents misunderstandings and ensures everyone is aligned on what 'done' truly means.
9 / 45
PR Description:
Subject: Implement User Profile Update API
Body:
This PR updates the user profile API endpoint to handle new data fields. All unit tests pass and integration tests are green. The code has been reviewed by John Doe and Jane Smith. However, the UI update for displaying the new profile information hasn't been completed yet.
What does the italicized section of the PR description primarily indicate regarding the Definition of Done?
The italicized section correctly points out that the DoD isn't solely based on backend code completion. A key aspect is ensuring *all* aspects of a user-facing feature are complete and working together seamlessly – in this case, displaying the updated profile information. The wrong options misinterpret the DoD as only relating to code completion or minor bugs; it represents a broader deliverable that encompasses the entire customer experience.
10 / 45
Mark is reviewing a PR for a new payment processing feature. The PR description states: 'All tests pass, and the code has been reviewed by two engineers.' However, Mark notices that the integration with the external payment gateway hasn't yet been fully tested. He comments on the PR: 'It looks good, but I'm concerned about the lack of end-to-end payment testing.' What does Mark's comment suggest about the Definition of Done (DoD)?
Mark's comment highlights a critical distinction: the Definition of Done isn't just about internal code quality (code review) but also encompasses external system integration. The DoD should reflect all necessary steps to ensure the feature functions correctly within its broader environment. This situation demonstrates that simply meeting internal criteria doesn't automatically constitute 'done' according to the team's established standards – it needs to align with the *actual* functionality required for the story.
11 / 45
Sarah (Developer): "Hey team, I'm about to merge this PR. The API response shows the user profile was updated successfully, and all tests are passing. But the documentation hasn't been updated yet – should I mark this as 'done'?"This scenario highlights a common misunderstanding about the Definition of Done. Simply passing automated tests or receiving code review doesn't automatically make a story 'done'. The DoD specifies *all* conditions that must be met for a story to be considered complete – in this case, it needs documentation updates to align with the data change. Marking it as 'done' prematurely risks delivering an incomplete feature and causing rework later.
12 / 45
Liam is pointing out that the DoD, in this case, isn't just about the code being written and tested. It's about *all* the necessary steps to ensure a story is truly complete – including deployments and infrastructure changes. The common misconception is that 'done' simply means functional; however, a robust DoD clearly defines all criteria that must be met before a story can be considered finished for that sprint. This emphasizes that 'done' isn't just about the code itself, but its integration with the system.
13 / 45
During a Slack conversation about a new feature, Alex writes: 'Okay, I've pushed the code to GitLab. The build succeeded and the tests are passing. It's ready for review.' Ben replies: 'Sounds good, but is it actually *deployed* to our staging environment?' What does Ben's question reveal about the importance of a clearly defined Definition of Done (DoD)?
Ben's question highlights a crucial gap in Alex's communication. Simply stating the build succeeded and tests pass doesn't guarantee the feature meets all DoD requirements. The DoD should encompass *all* criteria needed to confirm completion – including deployment to an environment where it can be realistically tested and validated, before formally accepting the story. This prevents misunderstandings and ensures everyone is aligned on what 'done' truly means.
14 / 45
PR Description:
Subject: Implement User Profile Update API
Body:
This PR updates the user profile API endpoint to handle new data fields. All unit tests pass and integration tests are green. The code has been reviewed by John Doe and Jane Smith. However, the UI update for displaying the new profile information hasn't been completed yet.
What does the italicized section of the PR description primarily indicate regarding the Definition of Done?
The italicized section correctly points out that the DoD isn't solely based on backend code completion. A key aspect is ensuring *all* aspects of a user-facing feature are complete and working together seamlessly – in this case, displaying the updated profile information. The wrong options misinterpret the DoD as only relating to code completion or minor bugs; it represents a broader deliverable that encompasses the entire customer experience.
15 / 45
Mark is reviewing a PR for a new payment processing feature. The PR description states: 'All tests pass, and the code has been reviewed by two engineers.' However, Mark notices that the integration with the external payment gateway hasn't yet been fully tested. He comments on the PR: 'It looks good, but I'm concerned about the lack of end-to-end payment testing.' What does Mark's comment suggest about the Definition of Done (DoD)?
Mark's comment highlights a critical distinction: the Definition of Done isn't just about internal code quality (code review) but also encompasses external system integration. The DoD should reflect all necessary steps to ensure the feature functions correctly within its broader environment. This situation demonstrates that simply meeting internal criteria doesn't automatically constitute 'done' according to the team's established standards – it needs to align with the *actual* functionality required for the story.
16 / 45
Sarah (Developer): "Hey team, I'm about to merge this PR. The API response shows the user profile was updated successfully, and all tests are passing. But the documentation hasn't been updated yet – should I mark this as 'done'?"This scenario highlights a common misunderstanding about the Definition of Done. Simply passing automated tests or receiving code review doesn't automatically make a story 'done'. The DoD specifies *all* conditions that must be met for a story to be considered complete – in this case, it needs documentation updates to align with the data change. Marking it as 'done' prematurely risks delivering an incomplete feature and causing rework later.
17 / 45
Liam is pointing out that the DoD, in this case, isn't just about the code being written and tested. It's about *all* the necessary steps to ensure a story is truly complete – including deployments and infrastructure changes. The common misconception is that 'done' simply means functional; however, a robust DoD clearly defines all criteria that must be met before a story can be considered finished for that sprint. This emphasizes that 'done' isn't just about the code itself, but its integration with the system.
18 / 45
During a Slack conversation about a new feature, Alex writes: 'Okay, I've pushed the code to GitLab. The build succeeded and the tests are passing. It's ready for review.' Ben replies: 'Sounds good, but is it actually *deployed* to our staging environment?' What does Ben's question reveal about the importance of a clearly defined Definition of Done (DoD)?
Ben's question highlights a crucial gap in Alex's communication. Simply stating the build succeeded and tests pass doesn't guarantee the feature meets all DoD requirements. The DoD should encompass *all* criteria needed to confirm completion – including deployment to an environment where it can be realistically tested and validated, before formally accepting the story. This prevents misunderstandings and ensures everyone is aligned on what 'done' truly means.
19 / 45
PR Description:
Subject: Implement User Profile Update API
Body:
This PR updates the user profile API endpoint to handle new data fields. All unit tests pass and integration tests are green. The code has been reviewed by John Doe and Jane Smith. However, the UI update for displaying the new profile information hasn't been completed yet.
What does the italicized section of the PR description primarily indicate regarding the Definition of Done?
The italicized section correctly points out that the DoD isn't solely based on backend code completion. A key aspect is ensuring *all* aspects of a user-facing feature are complete and working together seamlessly – in this case, displaying the updated profile information. The wrong options misinterpret the DoD as only relating to code completion or minor bugs; it represents a broader deliverable that encompasses the entire customer experience.
20 / 45
Mark is reviewing a PR for a new payment processing feature. The PR description states: 'All tests pass, and the code has been reviewed by two engineers.' However, Mark notices that the integration with the external payment gateway hasn't yet been fully tested. He comments on the PR: 'It looks good, but I'm concerned about the lack of end-to-end payment testing.' What does Mark's comment suggest about the Definition of Done (DoD)?
Mark's comment highlights a critical distinction: the Definition of Done isn't just about internal code quality (code review) but also encompasses external system integration. The DoD should reflect all necessary steps to ensure the feature functions correctly within its broader environment. This situation demonstrates that simply meeting internal criteria doesn't automatically constitute 'done' according to the team's established standards – it needs to align with the *actual* functionality required for the story.
21 / 45
Sarah (Developer): "Hey team, I'm about to merge this PR. The API response shows the user profile was updated successfully, and all tests are passing. But the documentation hasn't been updated yet – should I mark this as 'done'?"This scenario highlights a common misunderstanding about the Definition of Done. Simply passing automated tests or receiving code review doesn't automatically make a story 'done'. The DoD specifies *all* conditions that must be met for a story to be considered complete – in this case, it needs documentation updates to align with the data change. Marking it as 'done' prematurely risks delivering an incomplete feature and causing rework later.
22 / 45
Liam is pointing out that the DoD, in this case, isn't just about the code being written and tested. It's about *all* the necessary steps to ensure a story is truly complete – including deployments and infrastructure changes. The common misconception is that 'done' simply means functional; however, a robust DoD clearly defines all criteria that must be met before a story can be considered finished for that sprint. This emphasizes that 'done' isn't just about the code itself, but its integration with the system.
23 / 45
During a Slack conversation about a new feature, Alex writes: 'Okay, I've pushed the code to GitLab. The build succeeded and the tests are passing. It's ready for review.' Ben replies: 'Sounds good, but is it actually *deployed* to our staging environment?' What does Ben's question reveal about the importance of a clearly defined Definition of Done (DoD)?
Ben's question highlights a crucial gap in Alex's communication. Simply stating the build succeeded and tests pass doesn't guarantee the feature meets all DoD requirements. The DoD should encompass *all* criteria needed to confirm completion – including deployment to an environment where it can be realistically tested and validated, before formally accepting the story. This prevents misunderstandings and ensures everyone is aligned on what 'done' truly means.
24 / 45
PR Description:
Subject: Implement User Profile Update API
Body:
This PR updates the user profile API endpoint to handle new data fields. All unit tests pass and integration tests are green. The code has been reviewed by John Doe and Jane Smith. However, the UI update for displaying the new profile information hasn't been completed yet.
What does the italicized section of the PR description primarily indicate regarding the Definition of Done?
The italicized section correctly points out that the DoD isn't solely based on backend code completion. A key aspect is ensuring *all* aspects of a user-facing feature are complete and working together seamlessly – in this case, displaying the updated profile information. The wrong options misinterpret the DoD as only relating to code completion or minor bugs; it represents a broader deliverable that encompasses the entire customer experience.
25 / 45
Mark is reviewing a PR for a new payment processing feature. The PR description states: 'All tests pass, and the code has been reviewed by two engineers.' However, Mark notices that the integration with the external payment gateway hasn't yet been fully tested. He comments on the PR: 'It looks good, but I'm concerned about the lack of end-to-end payment testing.' What does Mark's comment suggest about the Definition of Done (DoD)?
Mark's comment highlights a critical distinction: the Definition of Done isn't just about internal code quality (code review) but also encompasses external system integration. The DoD should reflect all necessary steps to ensure the feature functions correctly within its broader environment. This situation demonstrates that simply meeting internal criteria doesn't automatically constitute 'done' according to the team's established standards – it needs to align with the *actual* functionality required for the story.
26 / 45
Sarah (Developer): "Hey team, I'm about to merge this PR. The API response shows the user profile was updated successfully, and all tests are passing. But the documentation hasn't been updated yet – should I mark this as 'done'?"This scenario highlights a common misunderstanding about the Definition of Done. Simply passing automated tests or receiving code review doesn't automatically make a story 'done'. The DoD specifies *all* conditions that must be met for a story to be considered complete – in this case, it needs documentation updates to align with the data change. Marking it as 'done' prematurely risks delivering an incomplete feature and causing rework later.
27 / 45
Liam is pointing out that the DoD, in this case, isn't just about the code being written and tested. It's about *all* the necessary steps to ensure a story is truly complete – including deployments and infrastructure changes. The common misconception is that 'done' simply means functional; however, a robust DoD clearly defines all criteria that must be met before a story can be considered finished for that sprint. This emphasizes that 'done' isn't just about the code itself, but its integration with the system.
28 / 45
During a Slack conversation about a new feature, Alex writes: 'Okay, I've pushed the code to GitLab. The build succeeded and the tests are passing. It's ready for review.' Ben replies: 'Sounds good, but is it actually *deployed* to our staging environment?' What does Ben's question reveal about the importance of a clearly defined Definition of Done (DoD)?
Ben's question highlights a crucial gap in Alex's communication. Simply stating the build succeeded and tests pass doesn't guarantee the feature meets all DoD requirements. The DoD should encompass *all* criteria needed to confirm completion – including deployment to an environment where it can be realistically tested and validated, before formally accepting the story. This prevents misunderstandings and ensures everyone is aligned on what 'done' truly means.
29 / 45
PR Description:
Subject: Implement User Profile Update API
Body:
This PR updates the user profile API endpoint to handle new data fields. All unit tests pass and integration tests are green. The code has been reviewed by John Doe and Jane Smith. However, the UI update for displaying the new profile information hasn't been completed yet.
What does the italicized section of the PR description primarily indicate regarding the Definition of Done?
The italicized section correctly points out that the DoD isn't solely based on backend code completion. A key aspect is ensuring *all* aspects of a user-facing feature are complete and working together seamlessly – in this case, displaying the updated profile information. The wrong options misinterpret the DoD as only relating to code completion or minor bugs; it represents a broader deliverable that encompasses the entire customer experience.
30 / 45
Mark is reviewing a PR for a new payment processing feature. The PR description states: 'All tests pass, and the code has been reviewed by two engineers.' However, Mark notices that the integration with the external payment gateway hasn't yet been fully tested. He comments on the PR: 'It looks good, but I'm concerned about the lack of end-to-end payment testing.' What does Mark's comment suggest about the Definition of Done (DoD)?
Mark's comment highlights a critical distinction: the Definition of Done isn't just about internal code quality (code review) but also encompasses external system integration. The DoD should reflect all necessary steps to ensure the feature functions correctly within its broader environment. This situation demonstrates that simply meeting internal criteria doesn't automatically constitute 'done' according to the team's established standards – it needs to align with the *actual* functionality required for the story.
31 / 45
Sarah (Developer): "Hey team, I'm about to merge this PR. The API response shows the user profile was updated successfully, and all tests are passing. But the documentation hasn't been updated yet – should I mark this as 'done'?"This scenario highlights a common misunderstanding about the Definition of Done. Simply passing automated tests or receiving code review doesn't automatically make a story 'done'. The DoD specifies *all* conditions that must be met for a story to be considered complete – in this case, it needs documentation updates to align with the data change. Marking it as 'done' prematurely risks delivering an incomplete feature and causing rework later.
32 / 45
Liam is pointing out that the DoD, in this case, isn't just about the code being written and tested. It's about *all* the necessary steps to ensure a story is truly complete – including deployments and infrastructure changes. The common misconception is that 'done' simply means functional; however, a robust DoD clearly defines all criteria that must be met before a story can be considered finished for that sprint. This emphasizes that 'done' isn't just about the code itself, but its integration with the system.
33 / 45
During a Slack conversation about a new feature, Alex writes: 'Okay, I've pushed the code to GitLab. The build succeeded and the tests are passing. It's ready for review.' Ben replies: 'Sounds good, but is it actually *deployed* to our staging environment?' What does Ben's question reveal about the importance of a clearly defined Definition of Done (DoD)?
Ben's question highlights a crucial gap in Alex's communication. Simply stating the build succeeded and tests pass doesn't guarantee the feature meets all DoD requirements. The DoD should encompass *all* criteria needed to confirm completion – including deployment to an environment where it can be realistically tested and validated, before formally accepting the story. This prevents misunderstandings and ensures everyone is aligned on what 'done' truly means.
34 / 45
PR Description:
Subject: Implement User Profile Update API
Body:
This PR updates the user profile API endpoint to handle new data fields. All unit tests pass and integration tests are green. The code has been reviewed by John Doe and Jane Smith. However, the UI update for displaying the new profile information hasn't been completed yet.
What does the italicized section of the PR description primarily indicate regarding the Definition of Done?
The italicized section correctly points out that the DoD isn't solely based on backend code completion. A key aspect is ensuring *all* aspects of a user-facing feature are complete and working together seamlessly – in this case, displaying the updated profile information. The wrong options misinterpret the DoD as only relating to code completion or minor bugs; it represents a broader deliverable that encompasses the entire customer experience.
35 / 45
Mark is reviewing a PR for a new payment processing feature. The PR description states: 'All tests pass, and the code has been reviewed by two engineers.' However, Mark notices that the integration with the external payment gateway hasn't yet been fully tested. He comments on the PR: 'It looks good, but I'm concerned about the lack of end-to-end payment testing.' What does Mark's comment suggest about the Definition of Done (DoD)?
Mark's comment highlights a critical distinction: the Definition of Done isn't just about internal code quality (code review) but also encompasses external system integration. The DoD should reflect all necessary steps to ensure the feature functions correctly within its broader environment. This situation demonstrates that simply meeting internal criteria doesn't automatically constitute 'done' according to the team's established standards – it needs to align with the *actual* functionality required for the story.
36 / 45
Sarah (Developer): "Hey team, I'm about to merge this PR. The API response shows the user profile was updated successfully, and all tests are passing. But the documentation hasn't been updated yet – should I mark this as 'done'?"This scenario highlights a common misunderstanding about the Definition of Done. Simply passing automated tests or receiving code review doesn't automatically make a story 'done'. The DoD specifies *all* conditions that must be met for a story to be considered complete – in this case, it needs documentation updates to align with the data change. Marking it as 'done' prematurely risks delivering an incomplete feature and causing rework later.
37 / 45
Liam is pointing out that the DoD, in this case, isn't just about the code being written and tested. It's about *all* the necessary steps to ensure a story is truly complete – including deployments and infrastructure changes. The common misconception is that 'done' simply means functional; however, a robust DoD clearly defines all criteria that must be met before a story can be considered finished for that sprint. This emphasizes that 'done' isn't just about the code itself, but its integration with the system.
38 / 45
During a Slack conversation about a new feature, Alex writes: 'Okay, I've pushed the code to GitLab. The build succeeded and the tests are passing. It's ready for review.' Ben replies: 'Sounds good, but is it actually *deployed* to our staging environment?' What does Ben's question reveal about the importance of a clearly defined Definition of Done (DoD)?
Ben's question highlights a crucial gap in Alex's communication. Simply stating the build succeeded and tests pass doesn't guarantee the feature meets all DoD requirements. The DoD should encompass *all* criteria needed to confirm completion – including deployment to an environment where it can be realistically tested and validated, before formally accepting the story. This prevents misunderstandings and ensures everyone is aligned on what 'done' truly means.
39 / 45
PR Description:
Subject: Implement User Profile Update API
Body:
This PR updates the user profile API endpoint to handle new data fields. All unit tests pass and integration tests are green. The code has been reviewed by John Doe and Jane Smith. However, the UI update for displaying the new profile information hasn't been completed yet.
What does the italicized section of the PR description primarily indicate regarding the Definition of Done?
The italicized section correctly points out that the DoD isn't solely based on backend code completion. A key aspect is ensuring *all* aspects of a user-facing feature are complete and working together seamlessly – in this case, displaying the updated profile information. The wrong options misinterpret the DoD as only relating to code completion or minor bugs; it represents a broader deliverable that encompasses the entire customer experience.
40 / 45
Mark is reviewing a PR for a new payment processing feature. The PR description states: 'All tests pass, and the code has been reviewed by two engineers.' However, Mark notices that the integration with the external payment gateway hasn't yet been fully tested. He comments on the PR: 'It looks good, but I'm concerned about the lack of end-to-end payment testing.' What does Mark's comment suggest about the Definition of Done (DoD)?
Mark's comment highlights a critical distinction: the Definition of Done isn't just about internal code quality (code review) but also encompasses external system integration. The DoD should reflect all necessary steps to ensure the feature functions correctly within its broader environment. This situation demonstrates that simply meeting internal criteria doesn't automatically constitute 'done' according to the team's established standards – it needs to align with the *actual* functionality required for the story.
41 / 45
Sarah (Developer): "Hey team, I'm about to merge this PR. The API response shows the user profile was updated successfully, and all tests are passing. But the documentation hasn't been updated yet – should I mark this as 'done'?"This scenario highlights a common misunderstanding about the Definition of Done. Simply passing automated tests or receiving code review doesn't automatically make a story 'done'. The DoD specifies *all* conditions that must be met for a story to be considered complete – in this case, it needs documentation updates to align with the data change. Marking it as 'done' prematurely risks delivering an incomplete feature and causing rework later.
42 / 45
Liam is pointing out that the DoD, in this case, isn't just about the code being written and tested. It's about *all* the necessary steps to ensure a story is truly complete – including deployments and infrastructure changes. The common misconception is that 'done' simply means functional; however, a robust DoD clearly defines all criteria that must be met before a story can be considered finished for that sprint. This emphasizes that 'done' isn't just about the code itself, but its integration with the system.
43 / 45
During a Slack conversation about a new feature, Alex writes: 'Okay, I've pushed the code to GitLab. The build succeeded and the tests are passing. It's ready for review.' Ben replies: 'Sounds good, but is it actually *deployed* to our staging environment?' What does Ben's question reveal about the importance of a clearly defined Definition of Done (DoD)?
Ben's question highlights a crucial gap in Alex's communication. Simply stating the build succeeded and tests pass doesn't guarantee the feature meets all DoD requirements. The DoD should encompass *all* criteria needed to confirm completion – including deployment to an environment where it can be realistically tested and validated, before formally accepting the story. This prevents misunderstandings and ensures everyone is aligned on what 'done' truly means.
44 / 45
PR Description:
Subject: Implement User Profile Update API
Body:
This PR updates the user profile API endpoint to handle new data fields. All unit tests pass and integration tests are green. The code has been reviewed by John Doe and Jane Smith. However, the UI update for displaying the new profile information hasn't been completed yet.
What does the italicized section of the PR description primarily indicate regarding the Definition of Done?
The italicized section correctly points out that the DoD isn't solely based on backend code completion. A key aspect is ensuring *all* aspects of a user-facing feature are complete and working together seamlessly – in this case, displaying the updated profile information. The wrong options misinterpret the DoD as only relating to code completion or minor bugs; it represents a broader deliverable that encompasses the entire customer experience.
45 / 45
Mark is reviewing a PR for a new payment processing feature. The PR description states: 'All tests pass, and the code has been reviewed by two engineers.' However, Mark notices that the integration with the external payment gateway hasn't yet been fully tested. He comments on the PR: 'It looks good, but I'm concerned about the lack of end-to-end payment testing.' What does Mark's comment suggest about the Definition of Done (DoD)?
Mark's comment highlights a critical distinction: the Definition of Done isn't just about internal code quality (code review) but also encompasses external system integration. The DoD should reflect all necessary steps to ensure the feature functions correctly within its broader environment. This situation demonstrates that simply meeting internal criteria doesn't automatically constitute 'done' according to the team's established standards – it needs to align with the *actual* functionality required for the story.
Frequently Asked Questions
What will I practice in "Definition of Done | Agile & Scrum Exercises"?
This is an Agile & Scrum exercise set. It walks through 45 scenario-based multiple-choice questions built around real usage of Agile & Scrum terminology that IT professionals encounter on the job.
Is this exercise free to use?
Yes. Every exercise on CoderSlingo, including this one, is free to complete with no account, sign-up, or paywall.
How many questions are in this exercise?
This set contains 45 questions. Each one shows immediate feedback and a detailed explanation after you answer, so you learn the correct usage right away rather than waiting for a final score.
Do I need prior experience to complete this exercise?
No prior experience is required. Each question includes a full explanation covering the reasoning behind the correct answer, so the exercise itself teaches the Agile & Scrum vocabulary as you go.
Can I retry the exercise if I get questions wrong?
Yes — use the "Try again" button on the results screen to reset your answers and go through all the questions again. There is no limit on attempts.
Is my progress saved?
Your answers and score for the current session are tracked in the browser as you go. No account or login is needed, and there is nothing to install.
What if I don't understand a term used in a question?
Read the explanation shown after you answer each question — it breaks down the correct term in plain English with a real-world example. You can also check the site Glossary for quick definitions.
How is this different from reading a blog article on the topic?
Exercises like this one are interactive drills that test and reinforce specific vocabulary through multiple-choice questions, while blog articles explain concepts in prose. Practising here after reading builds active recall, not just passive recognition.
Where can I find more Agile & Scrum exercises?
See the Agile & Scrum exercises hub for the full set of related pages, or browse all exercise categories from the main Exercises index.
Can I use this exercise to prepare for a technical interview?
Yes — Agile & Scrum vocabulary comes up often in technical discussions and interviews. Pair this exercise with our dedicated Interview Preparation section for role-specific practice.