Definition of done examples for software projects
Tags: agilewebandappde, agile, agileprojectmanage
Published: 2017-09-26 13:43:34

---
title: "Definition of done examples for software projects"
published: true
tags: Agile web and app de,agile,Agile project manage
canonical_url: https://apiumhub.com/tech-blog-barcelona/definition-of-done-examples-software-projects/
---

Definition of done is crucial to an [agile team](https://dev.to/apium_hub/what-you-should-know-when-building-an-agile-team). It is key to delivering high quality product and satisfying your management or client in terms of project management and results. To achieve this, you need to ensure that you are delivering features that are truly done, not only in terms of functionality but in terms of quality as well. Also, what is important to mention here is that sometimes features are iterative, there is always something to add or to check, so this definition of “done” is extremely important to understand to be on the same wave with your team. As it is easy to say but difficult to do, our agile team prepared definition of done examples, which will probably help you with your current project.

 

## What is DOD

 

But let’s start with the basics, what is DoD exactly ? Definition of Done as a shared understanding of what it means for work to be complete. To be honest, each agile team has its own Definition of Done. Basically, a team agrees on, and displays somewhere in the team room or in slack, google drive, whatever, a list of criteria which must be met before a product increment, normally it is a[user story](https://apiumhub.com/tech-blog-barcelona/user-stories-affect-team-product/) and there should be a clear definition of when it is considered “done”.

In other words, DoD is a checklist of features and activities, for example, writing code, coding comments, unit testing, integration testing, release notes, design documents, etc. that adds or demonstrates value to the product. Focusing on value-added steps allows the team to focus on what must be completed in order to build working software while eliminating wasteful activities that only complicate software development efforts.

Well, DoD is a good reporting mechanism for team members. It helps to say that “This feature is done.” Using DoD as a reference for this conversation a team member can effectively update other team members and the product owner.

 

## Definition of done examples

 

DoD can be different, but what is important to note here, is that the initial Definition of Done must be agreed before the first Sprint.

Let’s look at different types of DoD:

- Definition of Done for a feature ( user story or product backlog item)
- Definition of Done for a sprint (collection of features developed within a sprint)
- Definition of Done for a release (potentially shippable state)

For example, in software, a Definition of Done may be: “Done means coded to standards, reviewed, implemented with unit Test-Driven Development, tested with 100 percent test automation, integrated and documented.”

In a services context, it may be like this: “Done means every task under the User Story has been completed and any work created is attached to the User Story so the Product Owner can review it and make sure it meets his or her expectations.”

The idea of DoD is that it ensures everyone on the team knows exactly what is expected of everything the team delivers. It ensures transparency and quality fit for the purpose of the product and organization. What is more, moving tickets to done, makes team more motivated and efficient.

 

### Let’s look at definition of done examples for each type of DoD

 

**1.Definition of Done checklist for User Story**

This is the first and the most basic level is a User Story, where we check compliance with the initial assumptions of single backlog item, which were described in it. On this stage we also control quality of written code and check if all necessary elements of our process were carried out, for example:

- Produced code for presumed functionalities
- Assumptions of User Story met
- Project builds without errors
- [Unit tests](https://apiumhub.com/tech-blog-barcelona/top-benefits-of-unit-testing/) written and passing
- Project deployed on the test environment identical to production platform
- Tests on devices/browsers listed in the project assumptions passed
- Feature ok-ed by UX designer
- QA performed & issues resolved
- Feature is tested against acceptance criteria
- Feature ok-ed by Product Owner
- Refactoring completed
- Any configuration or build changes documented
- Documentation updated
- Peer Code Review performed

 

**2.Definition of Done checklist for Sprint**

The second stage is [Sprint](https://apiumhub.com/tech-blog-barcelona/scrum-sprint-explanation/), where we check the greater part of our work. Here we can see if all the implemented features fulfill their original assumptions and if all the required conditions for the production deployment were met.

- DoD of each single User story, included in the Sprint are met
- “to do’s” are completed
- All unit tests passing
- Product backlog updated
- Project deployed on the test environment identical to production platform
- Tests on devices/browsers listed in documentation passed
- Tests of backward compatibility passed
- The performance tests passed
- All bugs fixed
- Sprint marked as ready for the production deployment by the Product Owner

 

**3.Definition of Done checklist for Release**

- Code Complete
- Environments are prepared for release
- All [unit & functional tests](https://apiumhub.com/tech-blog-barcelona/top-software-testing-techniques/) are green
- All the acceptance criterias are met
- QA is done & all issues resolved
- All “To Do” annotations must have been resolved
- [OK from the team](https://apiumhub.com/software-developer-jobs-barcelona/): UX designer, developer, software architect, project manager, product owner, QA, etc.
- Check that no unintegrated work in progress has been left in any development or staging environment.
- Check that [TDD](https://apiumhub.com/tech-blog-barcelona/advantages-of-test-driven-development/) and [continuous integration](https://apiumhub.com/tech-blog-barcelona/benefits-of-continuous-integration/) is verified and working

 

Preparing a single definition of done that suits every situation is impossible. Each team should collaborate and come up with the definition that suits its unique environment. Teams that have just started with agile may find it difficult to reach a mature level immediately; therefore, they should take the steps, sprint-by-sprint, to improve their DoD and I really hope that these definition of done examples helped you! By the way, don’t forget about [retrospectives](https://apiumhub.com/tech-blog-barcelona/agile-retrospective-ideas/), feedback from retrospective meetings should also help to improve the definition of done.

 

If you are interested in agile, I recommend you to subscribe to [our monthly newsletter](http://eepurl.com/cC96MY) to receive latest news and best practices. 

 

## If you found this article with definition of done examples interesting, you might like…

 

[5 benefits you get by doing agile project management](https://apiumhub.com/tech-blog-barcelona/benefits-of-agile-project-management/)

[Agile games for team building ](https://dev.to/apium_hub/agile-games-for-team-building)

[How teams increase agility with agile retrospective](https://dev.to/apium_hub/how-teams-increase-agility-with-agile-retrospectives)

[What should you know when building an agile team](https://dev.to/apium_hub/what-you-should-know-when-building-an-agile-team)

The post [Definition of done examples for software projects](https://apiumhub.com/tech-blog-barcelona/definition-of-done-examples-software-projects/) appeared first on [Apiumhub](https://apiumhub.com).