Scrum Guide Decomposition, Part 4
We finish breaking down the Scrum Guide by tackling the infamous product backlog and coming up with a Definition of Done.
Join the DZone community and get the full member experience.Join For Free
this is the fourth and final part of the scrum deconstruction. you can find part 1 here , part 2 here and part 3 here . as mentioned previously, i did this as a method to help me understand the scrum guide better, and as part of my study for the scrum.org's psm i exam that i took back in october 2017. i have made updates based on the newest version of the scrum guide, november 2017.
here i share in the hope that someone finds it useful.
sections in blue will be taken from the scrum guide. i’m not going to do a cut and paste, but re-type out what is present. therefore there may be mistakes.
sections in black will be me rephrasing or my interpretations of the paragraph. this i would like to think of as the positive aspects of scrum.
sections in red will be the negative aspects that i see, or have been told, read or anything else negative. sometimes these will sound silly (and probably are) as it i find it difficult to find negative aspects, this is where i ask for help. if you have more constructive negative feedback about a paragraph, please let me know in the comments.
side notes are in green.
now, let's get on with the deconstruction.
the product backlog is an ordered list of everything that is known to be needed in the product. it is the single source of requirements for any changes to be made to the product. the product owner is responsible for the product backlog, including its content, availability, and ordering.
the product backlog is just a list of items. that list doesn't have to be user stories. it also doesn't have to be in jira.
it can be in excel, cards, word documents, or handwritten on paper. it isn't specified. the practices of how the backlog is kept is independent of scrum.
it is the single source of requirements. that means that if someone wants to do something, it must go on the product backlog, and since the product owner is in charge of the backlog, it must go on with their blessing.
that means that even if the ceo wants something done, they don't go directly to a developer, they go to the product owner. this means that the product owner position is one of respect, not someone who's a manager's lackey.
the list also needs to be ordered so that when the list is looked at during planning, or if the development team finishes the sprint backlog early, it is easily known what is the most valuable work is.
what if everything is of equal value? i've had that happen before!
then nothing is of value. this is an antipattern. the product owner wants everything, so everything is of equal value. this is then used to rush developers, which leads to shoddy work as the developers try to complete everything in the sprint. this then leads to technical debt and problems in the future.
there is always something of high importance/value. this needs to go first. then the next valuable piece of work and so forth.
a product backlog is never complete. the earliest development of it lays out the initial known and best understood requirements. the product backlog evolves as the product and the environment in which it will be used evolves. the product backlog is dynamic; it constantly changes to identify what the product needs to be appropriate, competitive, and useful. if a product exists, its product backlog also exists.
when you first start, you do not need to work out everything initially. it will all change anyway as new things are learned. you cannot know everything up front. what you know initially, start working on. work out the rest later. the later you can delay decisions, the more time you will give it to change. so that when it get time to do the work, hopefully — not always — the changes will be minimal.
the cone of uncertainty
as you get closer to the finish of the work, you start to get an idea of what the end will look like. at the beginning, you don't know what problems you will face, therefore in order to better predict the outcome, you need to work in small goals. by the end, you know exactly what needs to be done as you have already done it.
so focus on the short term while keeping in mind the long term. deliver to the short interval. you have a better idea of what you need to do now with regards to the work than for something you won't touch for a long time. yes, the work done can change, it may need to be re-done later, but you are delivering value sooner. it gets verified sooner, thus can be refined sooner.
this is why the product backlog should be dynamic.
even though the "project" is complete, changes, bugs, new features, an unfinished work still exists.
also, software does degrade. not in the same sense as mechanical degradation where parts wear, but the situation changes for software. what do i mean by this? well, a program will run flawlessly if the conditions it was written for do not change, be that hardware, volume, etc. but, those change in the real world. operating systems come and go out of service, they need security patches which changes the environment. volume changes: something built to handle 1,000 transactions an hour may not cope with 10,000 transactions five years from now.
also, the business environment changes. rules change, trading conditions change, which then means changes to the underlying program. so, while the product exists, these "additions" need to be looked at regularly and then determined if they are implemented or not.
these should be stored in the product backlog as well so that they can be worked on at a later date, when there is more time or budget.
the product backlog lists all features, functions, requirements, enhancements, and fixes that constitute the changes to be made to the product in future releases. product backlog items have the attribute of a description, order, estimate, and value. product backlog items often include test descriptions that will prove its completeness when "done".
the product backlog contains everything needed for the product. this includes db, servers and other non-functional as well as functional requirements.
each item should have a:
description: these tend to be in the form of stories: "as a.....i want....so that..."
but they do not have to be. they can be a header, a paragraph, a video, drawing. the important thing is that they have context to how the item fits in, and convey enough information to know what the work is.
order: generally, what is needed and most valuable is at the top, and the least valuable is at the bottom. make it easy for the team to know what to work on without them having to ask. also think, if you were to run out of money in the next sprint, what would you want most?
(just don't. as i mentioned above ask for everything.)
- estimate: so you have a guide as to how long or how much effort the item will take. note: scrum does not specify the method of estimation. you can use story points, t-shirt sizes, animal sizes, or dare i say it, time. there are reasons why you should not use time. i won't go through them here.
value: this could be in the form of roi, time saved, etc. this helps give context as to why the work is being done.
some companies include roi, even in non-scrum projects. the problem is that, at the end, the roi is never verified. you never know if the value is realized or not. this is not good.
- test descriptions: these help the developer know that they have built the right thing. again, there are many forms, but the more detail included, the better an understanding the developer has. tools like cucumber, fitnesse, and concordion can help automate verification by allowing tests to be described in english rather than code.
as the product is used and gains value, and the marketplace provides feedback, the product backlog becomes a large and more exhaustive list. requirements never stop changing, so a product backlog is a living artifact. change in business requirements, market conditions, or technology may cause changes in the product backlog.
the only way to know if the product will be useful is when it is used, hands-on. not labs, not trials, but real people using the product in anger. you will then know its shortfalls. the fixes, changes, extra functionality then gets added to the backlog.
a "product" is a long-lived thing, unlike a "project." requirements evolve, there is no end until the product dies for whatever reason.
multiple scrum teams often work together on the same product. one product backlog is used to decrease the upcoming work on the product. a product backlog attribute that groups items may be employed.
one product backlog, one source of value. everyone works together to get the most value sooner.
product backlog refinement is the act of adding detail, estimates, and order to items in the product backlog. this is an ongoing process in which the product owner and the development team collaborate on the details of the product backlog items. during product backlog refinement, items are reviewed and revised. the scrum team decides how and when refinement is done. refinement usually consumes no more than 10% of the capacity of the development team.
however, product backlog items are updated at any time by the product owner or at the product owner's discretion.
product backlog refinement is where you go through items in more detail. break down the items to smaller pieces of work. get acceptance criteria added. work out in detail what needs to be done for each item. not too much detail, but just enough. how much is enough? you have to work that out by trial and error. there are no easy rules. refinement should not take more than 10% of the time, but you can take less.
more meetings? when do you get the work done?
refinement is done anyway, even in waterfall projects. it's more hectic and ad-hoc when you do not specify a time. this is a requirements gathering process. rather than spend a whole heap of time up front, you are doing this during the development.
for developers, this may seem to be an issue. bas do the requirements gathering traditionally. put them together and hand them over to the developer for coding.
in scrum, there are no ba roles. you, the developer are the ba, the tester, and the developer. look at it as an opportunity to learn, not a "not my job" situation.
higher order product backlog items are usually clearer and more detailed than lower order ones. more precise estimates are made based on the greater clarity and increased detail; the lower the order, the less detail. product backlog items that will occupy the development team for the upcoming sprint are refined so that any one item can be reasonably "done" within the sprint time-box. product backlog items can be "done" by the development team within one sprint are deemed "ready" for selection in a sprint planning. product backlog items usually acquire this degree of transparency through the above described refining activities.
the closer you are going to work on an item, it needs to have more detail. this makes sense. why would you add more detail to an item you won't look at for some time, while neglecting upcoming work?
get the items to a point you can start and finish the work in a sprint. don't do half the work now and the other half next sprint. treat the work as if this sprint is you last. any subsequent sprints (even planned) is a bonus. at least during the planning.
this is a definition of "done" which we will get to later, but should there be a definition of "ready"?
the development team is responsible for all estimates. the product owner may influence the development team by helping understand and select trade-offs, but the people who will perform the work make the final estimate.
have you ever been in the situation where a manager gives you a piece of work, expects it to be done in a few days, but instead it took you a few months (i'm not talking scrum here, but traditional development)?
this statement is to give developers the ability to say it will take a few months, not a few days. they should know — they are doing the work.
monitoring progress towards goals
at any point in time, the total work remaining to reach a goal can be summed. the product owner tracks this total work remaining at least every sprint review. the product owner compares this amount with the work remaining at previous sprint reviews to assess progress toward completing the projected work by the desired time for the goal. this information is made transparent to all stakeholders.
this is giving the description burndown chart, without explicitly saying burndown chart because it limits thinking of other ways to describe the data, some of which are mentioned later in the guide.
this is basically the sum of all estimated work remaining compared to the previous sum. compared to all previous sprints you get a trend over time on how work progresses. this can be used as a guide to determine when the work will be completed.
various projective practices upon trending have been used to forecast progress, like burndown, burn-ups, or cumulative flows. these have proven useful. however, these do not replace the importance of empiricism. in complex environments, what will happen is unknown. only what has already happened may be used for forward-looking decision-making.
various examples are given to represent the data. what this data shows is a rate over time. think of this rate as showing your speed on an odometer. if you are on a freeway, your speed is 100kph. on a suburban road, it can drop to 50kph; a school zone and it’s 40kph. this is the known limits, and estimates can be derived data, but what happens if there is an accident on the road, road works, traffic, a special event? your rate changes, your estimated time of arrival (delivery) changes. these need to be taken into account — but after they occur. a good gps system will do this for your journey. you have to do the same thing for your journey in doing the work.
the sprint backlog is the set of product backlog items selected for the sprint, plus a plan for delivering the product increment and realizing the sprint goal. the sprint backlog is a forecast by the development team about what functionality will be in the next increment and the work needed to deliver that functionality into a “done” increment.
a sprint backlog is:
- selected items
- a plan for delivering of the increment and the goal.
it is a forecast, not a contract.
i have heard scrum masters mention commitment to the work. this language i think is dangerous. it can be taken as, "come hell or high water, this amount of work will be done."
this can lead to late nights, long hours, and working weekends to complete an ill-conceived sprint backlog. this is not what we want. a sprint is a timebox, not a deadline and we are trying to measure the "rate" of work at a reasonable pace
not "get all this stuff done before the sprint deadline."
we can get booked for speeding on the road. scrum masters should be booked for “speeding” their teams (driving them too hard) otherwise just like an engine, they will burn out.
the sprint backlog makes visible all the work that the development team identifies as necessary to meet the sprint goal. to ensure continuous improvement, it includes one high priority process improvement identified in the previous retrospective meeting.
this last statement of including at least one improvement is key to getting better. unfortunately, many teams do not do this or do not see it as a priority. thus it gets dropped off.
high-performance teams already do this, as mentioned by ken and jeff when this version of the scrum guide was released.
the sprint backlog is a plan with enough detail that changes in progress can be understood in the daily scrum.
the development team modifies the sprint backlog throughput the sprint. this emergence occurs as the development team works through the plan and learns more about the work needed to achieve the sprint goal.
unlike waterfall, with scrum, you do not work out everything up front. you are not supposed to. how many times have you worked on something only to find a detail that you forgot, didn’t know about, had a problem you could not solve and had to figure out a workaround? scrum takes these things as fact. shit happens. so don’t plan too far ahead because it is all going to change anyway. just plan enough to get by for now and a little ahead in the future. we learn as we go.
as new work is required, the development team adds it to the sprint backlog. as work is performed or completed, the estimated remaining work is updated. when elements of the plan are deemed unnecessary, they are removed. only the development team can change the sprint backlog during the sprint. the sprint backlog is highly visible, real-time picture of the work that the development team plans to accomplish during the sprint, and it belongs solely to the development team.
as the development team works, things missed get added to the sprint backlog, or something drops off in the sprint backlog back into the product backlog.
one thing about agile is that we try to minimize the work done. if something is no longer needed — drop it. don’t do it anymore. makes sense right? it is best to find out as early as possible if something is not needed so that you do not waste time even just thinking about the redundant item. it’s amazing how much work is done that is not required.
the sprint backlog should be visible to all. this is why you can see scrum/kanban boards. it’s a visible way to see the work.
by making it visible, everyone can see the progress. nothing is hidden.
monitoring sprint progress
at any point in time in a sprint, the total work remaining in the sprint backlog can be summed. the development team tracks the total work remaining t least for every daily scrum to project the likelihood of achieving the sprint goal. by tracking the remaining work throughout the sprint, the development team can manage its progress.
much like the product backlog, remaining work can be tracked, checked and determination of completing the work be done. this should be done at least daily, during the daily scrum. this is through moving the cards on a scrum wall — that is, if you use the scrum wall. what i have seen is that what is missed is checking if the sprint goal is likely to be accomplished. this statement again disproves the "what i did yesterday, what i will do today, any blockers" statement. these should be discussed and answered during the daily scrum, but they are not the only things that should be done during the daily scrum.
again, this emphasizes that this is a responsibility of the development team. the development team are masters of their domain.
the increment is the sum of all the product backlog items completed during the sprint and the value of the increments of all previous sprints. at the end of a sprint, the new increment must be "done," which means it must be in a usable condition and meet the scrum team's definition of "done." an increment is a body of inspectable, done work that supports empiricism at the end of the sprint. the increment is a step toward a vision or goal. the increment must be in usable condition regardless of whether the product owner decides to release it.
basically, an increment is all the work done to date that has been fully completed and is in a state that the product owner will find usable to some degree. by definition of "done," which is discussed later, it must be code reviewed, have error handling, follow standards, be tested and be at a point ready for release. by doing this up front — even for work that is not in a fully complete state, i.e. still has many months left to bring it to full spec, you:
- get feedback sooner. if left till fully ready after months, without checking you run the risk of not making what the client needs or wants.
- if the budget runs out, the client still has something usable. even after the first 2 weeks.
- it forces you to think in smaller chunks of value rather than just going for the whole thing.
the product owner is the best person to know when to release as they know when the product will give the most value to users and stakeholders.
by having the increment in a "done" state, there is no reliance on "fixing" bugs or any other trepidation before release as they should have been looked at beforehand.
scrum relies on transparency. decisions to optimize value and control risk are made based on the perceived state of the artifacts. to the extent that transparency is complete, these decisions have a sound basis. to the extent that the artifacts aren't completely transparent, these decisions are flawed, value may diminish and risk may increase.
have you ever worked on a project where you know that the whole thing will be a mess, you tell the project manager that it will last less than a day before it completely fails, but they release it anyway because the project manager told management everything was o.k.?
ever been in a project where everything was green up until a week before release? then everything changes to red?
these problems occur because information is hidden. it usually ends badly and it occurs so frequently that it is considered normal.
scrum relies on everyone knowing everything, and by everything, i mean the correct information. no lying or bending the truth. that way good decisions can be made.
but for this to happen, there must be an environment where it can happen without repercussions. in other words, there must be trust.
the scrum master must work with the product owner, development team, and other involved parties to understand if the artefacts are completely transparent. there are practices for coping with incomplete transparency. the scrum master must help everyone apply the most appropriate practices in the absence of complete transparency.
a scrum master can detect incomplete transparency by inspecting the artefacts, sensing patterns, listening closely to what is being said, and detecting differences between expected and real results.
it is the scrum master's job to try to teach the product owner and the development team to be transparent.
some technologies are:
- kanban board/scrum board to visualize the work.
- gather metrics — length of time of a ticket/item not worked on
- retrospective techniques
sometimes by just listening to the team, the scrum master can get a sense that something is wrong.
for example, mumbles about work, management, and hiding stuff from the product owner.
the scrum master must help the team expose these so they can be addressed.
the scrum master's job is to work with the scrum team and the organization to increase the transparency of artefacts. the work usually involves learning, convincing, and change. transparency doesn't occur overnight, but is a path.
the job of the scrum master is not an easy one, if done right. there is so much resistance to true agile. it is much easier to follow the "process" and be ignorant of the reasons as agile shows problems. it is far easier to hide and ignore those problems.
the road to transparency if long and arduous. it is a journey without end, which is fine as the journey is what is important — not the destination.
definition of done
when a product backlog item or an increment is described as "done," everyone must understand what "done" means. although this may vary significantly per scrum team members must have a shared understanding of what it means for work to be complete, to ensure transparency. this is the definition of "done" for the scrum team and is used to assess when work is complete on the product increment.
have you ever thought something was done only to find out that there was a requirement, or a portion of the work that needed to be done to complete the piece?
have you ever built something only to find out that it wasn't what the customer or end user had in mind and have to start all over again?
this is what the "definition of done" is for, to make sure everyone is on the same page, and has a shared understanding of what needs to be done to complete the work.
because everyone has their own understanding of a "requirement," the customers understanding needs to be "extracted" from the customers brain and "implanted" into the development team. my favorite method of doing this is through examples.
stealing from gojko adzic's book, specification by example .
let's say that the customer has asked for a "10 point star." a simple requirement.
so, you produce the following:
is this correct? well, that is up to the customer. in this case, the customer says "no, go back and try again!"
racking your brain, you have no idea what the customer is asking for. so you ask them to sketch it out.
huh? that's a five-point star!
no, says the customer. it's ten points!
"ah!" you now say. "i know what you are thinking!"
a simple example of what is expected can enlighten all on what is required. this will then reduce re-work and mistakes on misunderstandings.
other things can include having a list of what needs to be done, such as
- tested with automated tests
- following coding standards
- documentation complete
- meets acceptance criteria
- code reviewed
- no known defects
- user acceptance testedeven
- migrated to production
the same definition guides the development team in knowing how many product backlog items it can select during a sprint planning. the purpose of each sprint is to deliver increments of potentially releasable functionality that adhere to the scrim team's current definition of "done."
this means that you select items from the backlog that produce some functionality that is useful, not half of a piece of work one sprint and the other half the next sprint.
the next sprint should be considered a bonus that is not guaranteed. therefore, select items accordingly. reduce scope if need be.
development teams deliver an increment of product functionality every sprint. this increment is usable, so a product owner may choose to immediately release it. if the definition of "done" for an increment is part of the conventions, standards or guidelines of the development organisation, all scrum teams must follow it at a minimum.
if the product owner chooses to "release" the "functioning" product, this means that value is returned "sooner" than if the project was complete.
it also means that any learning from the product in production can be done sooner, thus determining if the work was valuable or not. if it is not, stop working on that feature and try something else. if it does, continue working on the feature.
if the product is "good enough," then the product owner may choose to not continue with the rest of the project. this is known as "chopping off the tail." there is no use continuing as all required functionality is already delivered.
this is another reason from a customer's perspective to get things in use by the users asap.
also, if the company has existing standards, incorporate them in the "definition of done," but review them regularly. you may find some no longer relevant or appropriate. a good place to look at this is a retrospective, but that should not be the only place. you should do it during the daily scrum, planning sessions, etc.
inspect and adapt!
if "done" for an increment is not a convention of the development organization, the development team of the scrum team must determine a definition of "done" appropriate for the product. if there are multiple scrum teams working on the system or product release, the development teams on all scrum teams must mutually define a "definition of done."
if there are no company-wide or team-wide conversions for "done," make your own. call out what you want to make it happen to make sure you make a quality product.
make sure that all scrum teams that work on the same product share the same quality values and "definition of done."
if you do not do this, you will find portions of the product in non-working order or of dubious quality.
it's just common sense.
get the teams to decide their "definition of done," but don't dictate it to them (unless it is an existing definition). if they define their own "definition of done," they have buy-in, and they may get more engaged.
the team may care more about meeting the "definition of done."
each increment is additive to all prior increments and thoroughly tested, ensuring that all increments work together.
each sprints output builds on previous sprints. this means that you need to make sure that past components developed still work. this means regression testing.
agile won't work easily with manual procedures. there just isn't enough time. therefore, you need to automate.
- automated regression testing
- automated deployment
basically, reduce the time it takes to do stuff.
but don't do it up front. do it along the journey. that way you only automate what you need to.
keep doing the improvement as you go along. that is the whole point.
as scrum teams mature, it is expected that their definition of "done" will expand to include more stringent criteria for higher quality. new definitions, as used, may uncover work to be done in previously "done" increments. any one product or system should have a definition of "done" that is standard for any work done on it.
the goal of scrum, in my opinion, is continuous improvement — not to keep the same pace, the same steady run. as you get better and stretch your abilities, your definition of done should also evolve.
this may include:
- severity goals, such as no p3 or p4 errors (ie, start with no p1 or p2 bugs, then start eliminating smaller bugs)
- reviewed by legal
- penetration testing
- performance testing
- continuous testing/integration/delivery
and any other criteria that you may wish to include.
you can't add this sort of thing until you get better, faster and more "agile." yes, i mean agile in the dictionary meaning — not as in the process or methodology.
scrum is free and offered in this guide. scrum's roles, events, artefacts, and rules are immutable and although implementing only parts of scrum is possible, the result s not scrum. scrum consists only in its entirety and functions as well as a container for other techniques, methodologies, and practices.
ok, for those that complain that you need certifications to so scrum or to be a scrum master, here is the proof that you do not need any of those things.
scrum is free!
i remember about 20 years ago, you had to pay to use the rational process to develop software. this is not the case with scrum.
also, those places that do "scrum" but do not do retrospectives or daily scrums/stand ups — you are not doing scrum.
saying that, you can still not be doing scrum if you follow the "process" to the letter but ignore the underlying reasons for the process, which is to get better. you get better by finding and fixing problems, not by blindly following a process. the process is there to guide improvement actively over a sprint, not organically as required whenever or every now and then through workshops or when a crisis happens.
remember the beginning. scrum is a framework on which to build improvement. techniques such as scrum boards, user stories, scrum poker, and story points are not part of scrum but still can be used. this is known as scrum — as opposed to scrum — but where only parts of scrum are used.
for those that are interested, as i mentioned in the first post, i have handwritten the scrum guide and my decomposition. you can find a copy here . fair warning: it's a large 80+mb pdf file.
i started this over a year ago when i decided to do this as part of my study for the psm i certification. hopefully you have found this useful. please let me know in the comments.
Published at DZone with permission of Holger Paffrath, DZone MVB. See the original article here.
Opinions expressed by DZone contributors are their own.