Sprint Backlog – Don’t Solve Half of the Problem

Every team that transitions to agile faces this problem – some stories are too big to fit in a single sprint.  Most of the teams that I have worked with have the wrong instinct – to solve half of the problem for all users.

The right approach is to first solve all of the problem for a subset of the users.

The Goal of the Story

User stories were created as lower-overhead use cases that served to better describe chunks of valuable software that could be rapidly developed, delivered, reviewed, used, and improved. Writing user stories that undermine that intent – rapid, valuable, incremental delivery – is a bad way to write user stories.

Imagine you are part of the team building GoToAssist, a product designed to do this. Your product manager and product owner put the following story into the top of your backlog – it is the most valuable capability you could add.

As a provider of IT support, I need to remotely resolve issues on multiple computers simultaneously, every day, so that those computers will run well.

The acceptance criteria include requiring that the solution working when accessing Apple computers, and PCs running various versions of windows and Linux. Other acceptance criteria include allowing the solution to work well through network connections having minimum characteristics, not requiring the remote users to take action, and other elements that characterize what would be considered acceptable solutions by the stakeholders.

Your team immediately raises a red flag that this user story is “too big” for a single sprint.

Since the goal of the sprint is to deliver valuable, shippable software, you have a problem with any user story that cannot be completed within a single sprint.

No problem, just decompose the user story into smaller user stories…

Inside-Out User Stories (Bad)

Note: Don’t confuse making smaller user stories with defining the tasks required to implement a user story. Task definition is important and valuable for helping the development team organize their activities.  Making smaller user stories is not a good approach for organizing the team’s activities – use tasks instead.  The size and structure of user stories should align with the user’s goals.

An inside out perspective or approach is one that starts with an awareness of what is involved in creating the software, and either never, or only later considers the perspective of what it is like use the software.

When approaching the problem inside-out, you will break the story down as follows:

  1. As a provider of IT support, I need to remotely gain access to multiple computers simultaneously…
  2. As a provider of IT support, I need to remotely authenticate as an administrator to each computer I access…
  3. As a provider of IT support, I need to remotely control each computer I access…
  4. As a provider of IT support, I need to remotely restore control of each computer…

This approach looks very appealing, because it is very clear what has to be done to support each new user story, and each new user story is appreciably smaller. Assume that each new user story is “small enough” for the team and does not need to be further reduced in size. It is very easy to see how the scope of development work has been reduced for each user story.

The problem shows up when you approach this schedule from a user’s perspective. Imagine that this product shipped with only stories 1 & 2, and not 3 & 4. How useful would the user find the product to be if she could remotely access a computer and authenticate, but not actually control the computer (to do her remote support work) or return control to the computer’s owner?

The reason you should not break the original user story up into these pieces is that the new stories do not independently represent delivery of valuable software. These proposed smaller user stories are atomic (each step is discrete), but each step has no independent value. The value is implicit in the sequence of steps, and is only realized when all four steps can be completed. The original story is already the smallest set of activities that allow the user to achieve his goal – a complete user story.

The problem with decomposing the original user story from the inside-out is that the new user stories don’t provide independent value to any of the users.

What about trying an approach that provides all of the value to some of the users?

Outside-In Story Decomposition (Good)

You are still faced with the challenge of making the story smaller, but now with the constraint of only delivering pieces that provide independent value. You need an approach that will work to split the story up per-user. “Provider of IT support” is an overly broad category of users – it is heterogeneous, within which different groups of users will use the product differently. I am a “provider of IT support” to my family, but I never have a need to access multiple computers simultaneously. I also don’t need to do this more than once a month on average. A corporate IT specialist responsible for 100 users would really benefit from simultaneous remote access to multiple machines – allowing her to multi-task, starting updates on a second machine while the first machine is working, etc.

There are at least two different personas that care about the “remote administration” user story, within the “provider of IT support” user category. One persona who needs to access only one machine at a time, and one persona who needs to access multiple machines simultaneously. This split allows you to decouple all of the work associated with managing simultaneous connections from the work associated with the sequence of steps (as applied through a single connection). This may reduce the size of the original user story enough to complete it in one sprint, but probably not, since it only “shaves off a little work.”

Another way to discover different sets of people who could benefit from delivering the user story differently is to look at the acceptance criteria.

Right off the bat, we’ve called out that the solution needs to work when the remotely accessed computers are running several different operating systems. You can make the user story smaller by constraining to one supported platform at a time. Whichever platform you pick first – say Linux – has some users who will value your solution. Start with them, then add another platform. Work with the product manager to determine how many customers in the market will require each platform or combination of platforms – that will guide the sequence in which you build support for each platform.

Another acceptance criteria required that the remote users not need to be involved – enabling “unattended” remote support – a key market differentiator. A key differentiator for the corporate IT specialist persona, who gets value from not having to coordinate support activities with multiple remote users. In fact, it is probably a must-have feature for those customers. As a family-support specialist, I don’t really have this need. My mom is going to call me, and I can fix her pc while we’re on the phone. I’m not trying to remotely administer her machine when a corporate policy has changed (on my schedule) – I’m doing it when a problem arises (on her schedule). This criteria can be deferred for a later iteration of the story

This approach works because, while it may be not be intuitive (from the inside) that this is a viable way to decompose the story, it makes send from an outside-in, user perspective.  Think about the different sources of value / problems, and how different people value solutions to the same problems differently.  The important characteristics of the problem will vary from one persona to another.

What About Development Efficiency?

As a developer, you may very correctly complain that this is a really inefficient development process. Some portion of the work done to enable controlling a single machine may need to be discarded and recreated in order to control multiple machines in parallel.

While these extra development costs are very visible, especially to developers, they are much smaller than the benefits that come from delivering the working software earlier. The cost of resolving bugs increases by orders of magnitude as you move through the product creation life cycle (from development to testing to deployment). The value of solutions also increases by orders of magnitude as they move through the process. Getting working product deployed earlier allows you to start realizing value (and therefore revenue) earlier.

That increase in revenue far outweighs the cost of a less-efficient development approach. Ignoring revenue side and focusing only on the cost side is being penny-wise but pound-foolish.

Dogma and Pragmatism

None of this should be taken as dogma. My experience has been that this approach has almost always worked, sometimes requiring more radical thinking than others. When it does not work (e.g. does not provide additional value, or does not sufficiently reduce the size of the stories), don’t do it. I’ll always remember Kent Beck saying to me – “If it costs more to test (in advance) than it costs to fix the bugs (after the fact), then don’t test.”

The same applies here, be pragmatic about it.

If you’ve been biting your tongue since the middle of the “Inside-Out” section, because you can always just wait until all four user stories are completed in separate sprints, before releasing the software, then my apologies. Of course you can do that. But you are undermining a precept of Scrum – that every sprint could be released, if you needed to release it.

That may not apply to you – I work with some teams that develop enterprise software, and for them, releasing every sprint makes no sense – their customers can’t absorb the rapid improvements, their sales teams aren’t willing to sell differently, etc. So, please forgive me, and go back and read the Outside-In section again, since you were probably ignoring that section as you started planning a great comment about this.

Who knows – a “too big” user story may appear in the backlog for the last sprint within your current release – wouldn’t it be great if you had the choice to release something (valuable) in the current release?

Think about this problem from an outside-in perspective. The smallest story is one that allows a single customer to perform a single task, for which he will pay you.

People Over Process – Conclusion

The objective that every sprint deliver valuable, working software, is not a requirement. It is a design principle of the Scrum process.

Agile is not about mandating processes, it is about getting better and faster. When you can’t reasonably decompose a story into something that can be delivered in a single sprint, don’t. You can have a sprint where you don’t deliver anything, because you only complete part of one thing. Yes, it will look bad on the burn-down chart.

Will it mess with your velocity? A bit. But who cares? Velocity is a measurement that helps inform projected delivery schedules. You may have one sprint with zero velocity, but in the next sprint, when you do deliver the “two sprint story”, you’ll have double the velocity. Magically, your running average is back to normal.

Don’t let the rulers you use to measure the team’s output cause you to act irrationally.

Attributions:

 

Post to Twitter Post to Facebook

This article was published on Wednesday, September 8th, 2010 at 9:19 am and is filed under Agile, Business Analysis, Product Management, Requirements, Requirements Models, Software development, User Stories.
You can leave a comment on this post

10 Comments

  1. Good stuff @sehlhorst “Don’t let the rulers you use to measure the team’s output cause you to act irrationally.” http://bit.ly/buPF5T

  2. OK, any example can be picked apart, so let’s see if doing it is useful for further conversation.

    1) Isn’t defining the clearest set of users/actors something you should do before or while writing stories? If done before, you may have never written the big story in this example.

    2) What if defining more user types doesn’t work? i.e. the user in the story does need all the functionality for the software to be useful? What other techniques would you use to address the big story?

    dww

  3. Hey David, GREAT questions.

    1. Pre-defining personas.

    Yes and no :). In my example above, instead of home support vs. IT support specialist, let’s split IT support specialists into groups – one with a ton of people to support, and one with very few people (or only a single location) to support. MAYBE those roles are different enough to justify pre-splitting them into different personas, but likely not. You don’t want more than 5 to 7 personas.

    The goal isn’t always to subdivide the persona by “who they are”, but rather “where the value is.” So maybe you split things up by market segment. Banking clerks probably need to do currency conversion, as part of some part of their work. Some clerks/branches would consider that to be critically important, while others may never (or effectively never) do it. A task-centric persona definition would lump the clerks together (probably) into the same persona. When considering the overall market, the product needs to include currency conversion. But for the subset of buyers/users who don’t care about currency conversion (or don’t care very much) can use the product without it.

    2. When “nothing works”, have a sprint that doesn’t deliver anything concrete. That’s my escape clause. :).

    You can split things based on the subset-of-user approach above, look at supported platforms, operating systems, languages, etc – that sort of thing.

    You can also, for (Kano) more-is-better features, introduce the “slow” version now, and the “fast” version update later – if some of your customers aren’t as hung up on speed as other customers.

    You don’t want to “do it” now, and “do it better” later where “better” is quality, or user experience. And you should worry about “will having a slow version for a month hurt us in the market?” Balance that against the perfectionist-paralysis mindset of not delivering anything until it is perfect. There’s the whole satisficing thing to keep in mind.

    You can also consciously and conspicuously choose to incur technical debt to deliver functionality now, and refactor later. This is dangerous, because none of your stakeholders will be pushing you to pay back that debt until it is cripplingly large and probably way too late.

    That enough options? :)

  4. Scott,

    I do think there are indeed cases where you have to build a certain amount of underlying structure before value can be realized. There is always a logical build sequence to be considered; you can’t deliver reports on function throughput if you haven’t built the function yet. I may consider the a/c in my car to be its most valuable feature, but it is not what gets built first.

    I also strongly agree that delivering too often can cause to much change for a business to absorb without impacting its operations.

    Certainly long development cycles of months and months are not acceptable anymore, but some balance between value delivery and cost of change has to be determined for an organization.

  5. @David –

    Yup. There’s definitely real rationale for releasing some product updates quarterly or semi-annually. I’ve seen two very solid justifications: cost of change for the customers (to upgrade), and cost of change for the sales team (to update positioning, messaging, training etc).

    However, that doesn’t mandate that the product only be released twice a year. You could release monthly, with each customer on a semi-annual upgrade cadence (jumping forward 6 versions at a time). The downside of this approach is the added cost of supporting (ever more) multiple versions of software in the field.

    To your point – it is a trade-off each organization needs to make based on their reality: is added cost offset by added value/competitiveness of rapid public releases?

    In either case, the team should work on a rapid cadence. I like the model that Google Chrome (and other software products use) – there’s a “latest release” and a “latest stable release” – and each customer can be on either. Obviously, that labeling would be bad, but it may help to have a bleeding-edge-version available to customers who want it.

  6. @David –

    On infrastructure before value:

    Also agree. But you need less infrastructure for “some of the users” than you do for “all of the users.” You have the option to refactor the enabling-technologies on the fly. When that costs more, don’t do it that way :). It doesn’t always, but I agree – it definitely can.

    Thanks again for the great dialog!

  7. @Scott and David,

    Using a minimal marketable functionality (MMF) approach limits the impact of changes on users. This approach has you delivering one complete function at a time. This function is complete, rather than minimally viable. Treat the collection of ultimately delivered functionality as a collection of functions, where the functions can be networks of functions.

    MMFs enable customers/users to realize some value early. It also allows them to learn a function before they are presented with another function. This is can be consistent with any instructional design related to that functionality. Further, it can be used to move instruction costs from the post-install into the pre-release marketing efforts.

    Another way to divide the big user task would be to break it down into a hierarchy of tool tasks, stuff done because it is software, like opening a file, and user tasks, the real work tasks built up of tool tasks.

  8. I really like the below section of the post:

    “While these extra development costs are very visible, especially to developers, they are much smaller than the benefits that come from delivering the working software earlier. The cost of resolving bugs increases by orders of magnitude as you move through the product creation life cycle (from development to testing to deployment).”

    And this part has clear value proposition even for development teams:
    ” Getting working product deployed earlier allows you to start realizing value (and therefore revenue) earlier.”

    The problem that I see here is, many of the business analysts or product managers (at least those I’ve seen) are coming from engineering background. They usually have a “Feature/Deliverables” approach rather than “Benefit/Value”.

    What David has pointed out in regards to building up the infrastructure first, is very valid, however, balancing out the immediate value and future maintenance issues is something which need really experienced people.

    • Thanks, Alidad, and welcome to Tyner Blain!

      My experiences parallel yours somewhat – I’ve worked with very many people on solution teams who approach a problem from their perspective, rather than focusing outside-in from the customer’s perspective.

      I don’t know that I’ve met any decent BA or product manager who was feature-fixated, who after having a value-based “see the light” conversation, didn’t embrace an outside-in view of their products and the real-world problems they solve. I always approach this issue with individuals by advocating for the customer’s point of view, in a “think about the problem this way,” conversation. So far, folks have always agreed. I think this is 1% due to my persuasiveness, and 99% due to the truth of my argument. :)

      Infrastructure-first is tricky. When you’re not talking in specifics, it becomes a philosophical debate. I try and avoid the fighting dogmas, and focus on the potential value relative to actual costs. If launching 6 months earlier does not generate enough profit to more than offset the (in my experience, much smaller) costs of reworking infrastructure down the road, then build it “right” first. But don’t kid yourself – you don’t really know what “right” is at the start. Regardless, each team has to decide.

      The danger of building on fragile infrastructure, of course is a mixture of misreading how things will evolve – your infrastructure may be bulletproof in terms of scalability, but weak in terms of security, when your market requires the opposite. And you may do damage with “not what the market wants” being launched early. That’s not what I recommend :).

      Another latent, and perhaps more insidious risk, particularly in larger organizations, is the hard-to-quantify cost of carrying technical debt. It can be difficult (and expensive) to convince stakeholders that what they perceive as “good enough” isn’t. I’ve personified “the system” as a stakeholder, and (alternately) included a member of the delivery team as a stakeholder – to make sure the “keep the system healthy” contingent has a voice.

      Thanks again!

  9. In our company we are using a web based service – Manitoo Project Management. It is quite new and is only being released to the public, but we use it with a great success to manage either simple requests from customers or complex long-lasting tasks. We are a team of 5 programmers and thanks to this tool we all know about each other and what are our duties. Or – what are the duties of the others. And we do not need to sit at one office. Visit http://www.manitooprojectmanagement.com to read more. Thanks.

30 Trackbacks

  1. By Robert Huberts on September 8, 2010 at 3:47 pm

    By @sehlhorst: Sprint Backlog – Don’t Solve Half of the Problem http://bit.ly/b1N0yL

  2. By marquinhosarm on September 8, 2010 at 4:31 pm

    By @sehlhorst: Sprint Backlog – Don’t Solve Half of the Problem http://bit.ly/b1N0yL

  3. By Aldon ALM Software on September 8, 2010 at 5:38 pm

    Stories too Big? Sprint Backlog – Don't Solve Half of the Problem http://bit.ly/9aC0aX New Tyner Blain #prodmgmt #agile #scrum

  4. By Jeffrey Davidson on September 8, 2010 at 5:56 pm

    Reading: Don't Solve Half the Problem by @selhorst, http://bit.ly/buPF5T | another great article by Scott

  5. By Jeffrey Davidson on September 8, 2010 at 5:57 pm

    JeffreyGoodReq Reading: Don't Solve Half the Problem by @selhorst, http://bit.ly/buPF5T | another great article by Scott #baot #scrum

  6. By SolutionsIQ on September 8, 2010 at 7:08 pm

    Sprint Backlog – Don’t Solve Half of the Problem http://ow.ly/2Bjxl Handling stories too big for a single sprint #agile #scrum

  7. By Sara BROCA on September 8, 2010 at 9:35 pm

    Sprint Backlog – Don’t Solve Half of the Problem http://j.mp/bnRRVj #agile

  8. By mbaker000 on September 8, 2010 at 10:37 pm

    Good stuff @sehlhorst "Don’t let the rulers you use to measure the team’s output cause you to act irrationally." http://bit.ly/buPF5T

  9. By barbaragnelson on September 9, 2010 at 12:27 am

    RT @sehlhorst: Sprint Backlog – Don't Solve Half of the Problem http://bit.ly/9aC0aX New Tyner Blain #prodmgmt #baot #agile #scrum

  10. By Barry Latimer on September 9, 2010 at 12:27 am

    RT @sehlhorst: Sprint Backlog – Don't Solve Half of the Problem http://bit.ly/9aC0aX New Tyner Blain #prodmgmt #baot #agile #scrum

  11. By Tedd Huff on September 9, 2010 at 1:33 am

    RT @sehlhorst: Sprint Backlog – Don't Solve Half of the Problem http://bit.ly/9aC0aX New Tyner Blain #prodmgmt #baot #agile #scrum

  12. By bishoph on September 9, 2010 at 11:47 am

    Excellent: Agile is not about mandating processes, it is about getting better and faster: http://bit.ly/9FkDSd

  13. By Vlad Nemes on September 9, 2010 at 12:52 pm

    Sprint Backlog – Don’t Solve Half of the Problem: Shared by vlad

    If it costs more to test than it costs to fix … http://bit.ly/dsryGm

  14. By Adrian Logan on September 9, 2010 at 5:22 pm

    TynerBlain: Sprint Backlog – Don’t Solve Half of the Problem http://is.gd/f2Ll1 #agile

  15. By Hunac on September 10, 2010 at 8:06 am

    By @sehlhorst: Sprint Backlog – Don’t Solve Half of the Problem http://bit.ly/b1N0yL

  16. By Marcel van der Laan on September 10, 2010 at 8:27 am

    Reading: "Sprint Backlog–Don’t Solve Half of the Problem" by @sehlhorst about decomposing user stories the *right* way. http://bit.ly/b9Fthx

  17. By Nicole Reineke on September 10, 2010 at 2:54 pm

    Agile article by @sehlhorst re: splitting user stories. Something I've struggled with, too – sometimes you just cant. http://bit.ly/b1N0yL

  18. By Karyn Crouse on September 10, 2010 at 3:57 pm

    Reading: Sprint Backlog – Don't Solve Half of the Problem http://bit.ly/9aC0aX

  19. By Pablin Mazzeo on September 10, 2010 at 4:18 pm

    By @sehlhorst: Sprint Backlog – Don’t Solve Half of the Problem http://bit.ly/b1N0yL

  20. By Pablin Mazzeo on September 10, 2010 at 4:20 pm

    RT @sehlhorst: Sprint Backlog – Don't Solve Half of the Problem http://bit.ly/9aC0aX #in

  21. By João Cerdeira on September 13, 2010 at 10:18 pm

    By @sehlhorst: Sprint Backlog – Don’t Solve Half of the Problem http://bit.ly/b1N0yL

  22. By Jon Harmer on September 14, 2010 at 6:24 pm

    Good post on agile and user stories – RT @sehlhorst: Sprint Backlog – Don't Solve Half of the Problem http://bit.ly/9aC0aX

  23. By Eric Provost on September 14, 2010 at 9:46 pm

    Sprint Backlog – Don’t Solve Half of the Problem http://j.mp/aeyq12

  24. By cindyalvarez on September 29, 2010 at 4:31 pm

    "The right approach is to first solve all of the problem for a subset of the users" http://bit.ly/cwWdzM #prodmgmt #leanstartup

  25. By Sara BROCA on October 3, 2010 at 2:45 pm

    @DSN_XP maybe this post can help you : http://bit.ly/bRACUz

  26. By Paco Toscano Morales on October 3, 2010 at 3:00 pm

    RT @sara_broca: @DSN_XP maybe this post can help you : http://bit.ly/bRACUz lectura recomendada :o) #DSN_XP

  27. By Introit on October 7, 2010 at 10:55 pm

    By @sehlhorst: Sprint Backlog – Don’t Solve Half of the Problem http://bit.ly/b1N0yL

  28. By barbaragnelson on January 21, 2011 at 8:12 pm

    Great post! Sprint Backlog-Don’t Solve Half of the Problem http://bit.ly/eZqTb8 #prodmgmt #agile perfect 'cause I'm Livin in Agile World 2dy

  29. By Allison L. Weiss on December 21, 2011 at 5:00 am

    "Sprint Backlog – Don't solve half the problem" http://t.co/PZVzWdT2

  30. [...] research for this problem I have found some decent resources. There is a really good post over on Tyner Blain which talks about focusing on personas and solving all the problem for one persona instead of [...]

Post a Comment

Your email is never published nor shared. Required fields are marked *

*
*

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>