Tuesday, February 1, 2011

Iterative Development and User Story Slicing

You may have seen Jeff Patton's slides showing iterative vs. incremental development using the Mona Lisa as an example (slides are here, page 80, 81). Iterative development suggests that you build each feature from the ground up increasing the subjective quality of each feature with each user story that you implement. This method is important for allowing you and your team to narrow in on the final solution rather than designing and understanding it all up front. It also allows you to deliver a full featured application earlier and to use methods like trim the tail to optimize your available budget vs the value that the project is delivering.

Here is a quick discussion on Iterative vs Incremental development:

The diagram to the left shows how a project could be completed using Iterative or Incremental development. In both cases, iterations were used to develop the list of features, but in iterative development we build each feature up a slice at a time rather than a feature at a time. Some of the advantages of iterative development are that it:
  • Allows you to validate your architecture and solution early
  • Allows users to see and test the whole application early
  • Minimizes the affects of change to a feature
  • Ensures important stories are built first
  • Elicits improved feedback on the whole application early
  • Allows you to deliver your application early
  • Discourages "gold plating"
  • It partners nicely with user story mapping (turn the diagram upside down and you have your story map)
Some of the disadvantages are:
  • Your code and design has to be change tolerant
  • You have to be proficient at slicing your user stories
  • You won't know the final solution at the beginning of the project
User story slicing is an important technique in iterative development, but what does this look like in practice? Using Jeff's Mona Lisa pictures as a pattern, I've created a few images that show how a feature like "Send Email" could be completed iteratively.

The first story slice is simply a form with little or no validation with text boxes To, Subject and Body with Send and Cancel buttons. When the user fills in the text boxes and clicks Send an e-mail is sent provided the e-mail addresses entered are correct. But, this e-mail has no extra features like support for HTML formats, RTF, attachments, e-mail priorities, etc. Once this story is implemented, the team will implement similar slices of each feature for Read Email, Create Appointment, View Calendar, Create Task, Edit Task, Create Contact, Edit Contact, etc in order to create a minimalist working model of the whole application.

The next slices of this particular feature would be to implement stories such as implementing Carbon Copy (CC) and taking e-mail addresses from your contact list. You can also see that the form has changed slightly - the Cancel button has been removed and the Send button has been moved to the top.

As we continue to iterate through this feature by adding story slices, the form takes additional shape, adding tool bars and tool bar items. At this point, the application may be finished enough to release to production and start earning revenue for the organization while we continue to add new features and use that revenue to help fund the remainder of the project.

A further release with more story slices implemented:

The final release:

Iterative development is an important tool in your agile toolbox to help your teams deliver early and adapt to change while keeping the project's end goals in mind. User story slicing is one of the important techniques you can use to help make this happen.

Want to receive future blog posts in your inbox? Enter your email address here.


  1. very good, thanks but I have just one comment.

    you write
    "As we continue to iterate through this feature by adding story slices, the form takes additional shape, adding tool bars and tool bar items."

    I'm reacting at the word "adding" in this statement.

    Do we add things (new features, functionality) in iterative model?
    i thought we add new features (funcctionality) in the incremental model and not in iterative model.


  2. I'm not sure I understand the question, because we add things in both models.

    In the first diagram above, think of each 'cell' as one user story. In both models we can 'add' (deliver) one user story at a time, but it is the order of what we 'add' that matters.

    In an iterative approach, we *add* to each feature by delivering user stories left to right across each feature (more or less). In an incremental approach we *add* to each feature by delivering user stories bottom up and finish each feature before moving to the next one.