Done!

Note: this post is based on the 2017 version of the Scrum Guide and has not been updated since.

The most crucial sprint objective in Scrum is to deliver a DONE product increment – a piece of working software delivering value for the end user. That is the goal today and always has been the goal.

In a context in which multiple Scrum teams work on the same product, it’s the goal – and only goal –  to deliver each (and every) sprint an integrated product increment – so no UNDONE work is left at the end of the sprint.

How do you define DONE?

Scrum does not define what “done” means for a product – that’s to be determined by the development team.

Yet the goal is to improve and raise the bar to deliver valuable working software at the end of each sprint.

With the support of the Scrum Master, the development team improves their practices at a steady pace to reach that goal.

The Scrum Guide describes:

“As Scrum Teams mature, it is expected that their definitions of “Done” will expand to include more stringent criteria for higher quality. Any one product or system should have a definition of “Done” that is a standard for any work done on it.”

Unfortunately, many Scrum teams (or teams saying to practice Scrum) cannot deliver a done product increment at the end of each sprint. Some teams do not care and finish the work at the next sprint. In software development, this means a piece of working software (end-to-end) ready to be used by a customer (end-user).

The output at the sprint has been called a potentially shippable product increment. Some teams interpreted this as “the product increment is ready to be shipped, but there’s still work to do to release it to the customer.” That’s not the point.

That’s why the Scrum Guide describes:

“The Development Team consists of professionals who do the work of delivering a potentially releasable Increment of “Done” product at the end of each Sprint.”

A lesson from Scrum history

Jeff Sutherland and Ken Schwaber, – Scrum creators- have updated the Scrum guide over time. It’s interesting to read how there were more details about what done means and what to do with “undone” work in previous versions of the Scrum guide. In general, some artifacts and pieces have been left out to make the description of Scrum as a framework simpler, more straightforward to understand, and lighter.

From Scrum Guide, version 2009:

A completely “done” increment includes all of the analysis, design, refactoring, programming, documentation and testing for the increment and all Product Backlog items in the increment. Testing includes unit, system, user, and regression testing, as well as non-functional tests such as performance, stability, security, and integration. Done includes any internationalization.

You get the picture that “done” includes all the work necessary for a piece of releasable, valuable software at the end of the sprint.

It continues:

“Undone” work is often accumulated in a Product Backlog item called “Undone Work” or “Implementation Work.”

Sprint by Sprint, the “undone” work of each increment is accumulated and must be addressed prior to releasing the product. This work is accumulated linearly although it actually has some sort of exponential accumulation that is dependent on each organization’s characteristics. Release Sprints are added to the end of any release to complete this “undone” work. The number of Sprints is unpredictable to the degree that the accumulation of “undone” work is not linear.

Take care. The current Scrum Guide does not specify a “release sprint” as a practice. This is similar to the “hardening” sprint defined in – for example – the Scaled Agile Framework. The only goal is to create a done product increment at the end of each sprint. In Scrum, this is considered a bad practice. “Undone” work piles up and increases risks and delays.

The word “undone” is no longer mentioned in the Scrum Guide’s current version.

A perfect definition of done

Large-Scale Scrum (LeSS) (by Craig Larman and Bas Vodde) explicitly mentions “undone” work – in larger organizations. There are often whole teams (e.g., an “operations” team, a “services” team) or whole departments (“operations” department) or people (“release manager”) existing, which are to be considered part of “undone” work if this cannot be done as part of the sprint (and it often cannot be done within a sprint).

A definition of “done” implies that each product increment is

  • valuable
  • immediately releasable to the end-user

And that should be the goal of done.”

To be able to achieve this as a team, the effort is necessary to invest in:

  • software craftsmanship
  • automated testing
  • continuous integration
  • deployment automation

without sound technical practices, it’s pretty impossible to accomplish this on any scale (small or large).

Do not make a mistake. This is quite a challenge for many teams who (try to) practice Scrum.

According to the rules stipulated in the Scrum guide, all variants on Scrum that do not achieve the actual state of “done” product increments are not considered Scrum teams.

What does “done” mean in software development?

I quote this from – Ken Schwaber – and any software development team should adhere to these (working in Scrum or not)

The result should include software that has the following:

  • Presence of valuable functionality for customers to use;
  • Absence of low-value functionality that must be maintained and sustained regardless;
  • Quality code base to predictably maintain and sustain;
  • Quality code base to enhance without undue effort or risk;
  • Ability to catch defects early and no later than at release;
  • Predictability of schedules; and,
  • A Lack of surprises.

This raises the question, what is quality software?

It has these characteristics:

  • I can readily understand the software and where & how things happen;
  • When I change or add to part of the software, there are no unintended or poorly designed dependencies;
  • I can read the code without looking for tricks or ill-defined and labeled variables or data;
  • I don’t need the person(s) who wrote the code to explain it to me;
  • Therecompletea full set of (automated) tests to check that the function works as expected;
  • When I change something and add to the tests, I can check that the entire change and product continue to work;
  • How things work and hang together is transparent;
  • Standard, well-known design principles have been adhered to.

Source: Quality, Done Increment

Keep on improving!