Your backlog lines up dozens of user stories ranked by priority and, when a business director asks you what the first release will be able to do, all you have to show them is a list. Agile story mapping addresses this difficulty. It is a workshop technique that arranges user stories along two axes: from left to right, the user’s journey told in order; from top to bottom, what is essential and then what can wait. The resulting map shows the whole product, and horizontal lines slice it into releases.
The workshop follows an order: bring the right people together on a bounded scope, set out the journey, go down into the detail, read the map aloud, mark out the releases, then feed the result back into the backlog. Each step leaves something on the wall.
Agile story mapping, a two-axis map in place of a list
The term is attributed to Jeff Patton, who himself says he coined it. He described the practice in an article from January 2005, “How You Slice It”, then in a blog post of 8 October 2008, “The New User Story Backlog is a Map”, before devoting a book to it, “User Story Mapping”, published by O’Reilly. In the 2008 post, he levels three criticisms at the “flat” backlog: it does not explain what the system does, it does not help to spot omissions and it makes release planning painful. He states there that he has seen other practitioners arrive at similar models, and speaks of a recurring pattern.
His answer keeps the big stories instead of dissolving them in the list. The user’s activities form the top row, which he calls the backbone. Below come the user’s tasks, smaller user stories arranged under the activity they serve. The vocabulary used here is that of this post; the workshop sequence that follows, with its additional level of detail, is one way among others of putting it into practice.
Whom to bring together, and on what scope
Before the session, the product owner sets the problem being addressed, the target users and the limits of the scope. Without these reference points, the map spreads in every direction. If they are missing, they fall under product framing, presented on our page on custom software development.
Around the map stand those who know how the product is used and those who will build it: the product owner, one or two representatives of the users or the business, developers, a person responsible for testing and, if there is one, the person responsible for designing the user journeys. A facilitator keeps the pace and makes sure everyone writes. An architect joins the group when the product depends on other applications.
A group without a business representative risks mapping the screens the team imagines. A group without a developer produces a map whose feasibility nobody has judged. The preparation leaves on the wall a one-sentence objective and the list of user types.
The journey told from left to right
The first step of the workshop consists of writing the activities: the big things the user does with the product, one per card, expressed with a verb. For a room booking application, for example: search for a room, book, change a booking, administer the rooms. The group lines them up from left to right. When the order is debated, Jeff Patton gives a rule: it is the order in which you would explain the system to someone.
This row is the backbone. It is not prioritised, since a booking application without search or confirmation does not provide the expected service.
The second step places the user’s tasks under each activity, still in the order of the story. Under “book”: choose a time slot, invite participants, confirm. Everyone first writes alone, then the group gathers the cards, removes duplicates and puts them in order.
The result is a view of the whole product, which the business can read without knowing the team’s vocabulary.
Under each task, the variants, the exceptions and the questions
The third step goes down into the detail. Under each task, the group writes finer user stories: the variants (book a room every week), the exception cases (the room has just been taken), the rules (an unconfirmed booking is released). A question without an answer receives a card of another colour and a name, that of the person who will go and find the answer.
The fourth step is a read-through. One person walks through the map aloud, from left to right, as if telling the story of a user’s day. Another repeats the journey for a second type of user. The gaps appear at this moment: a step is missing, two tasks are reversed, an entire activity has been forgotten. Jeff Patton describes this use in his post, where he recounts that users point out the steps he has missed when he walks through the map with them. The business representatives play the leading role here.
At this stage, the wall carries a complete map for the chosen scope and a list of open questions, each one assigned.
Horizontal lines for the releases, then back to the backlog
The fifth step concerns necessity. In each column, the group moves up the cards without which the journey does not work and moves the others down. The top row then describes the smallest system that works end to end. Jeff Patton compares it to Alistair Cockburn’s “walking skeleton” and says he seeks to build it first.
The group then draws horizontal lines, with adhesive tape if working on a wall. Each band is a release. We advise defining it by the result expected for the user and by the way of verifying it after go-live, before placing the cards in it. Each band crosses the whole map: a little of each activity, rather than one completed activity alongside empty ones.
The product owner makes the calls, the developers say what fits in a band, the business says what it cannot do without. The result is a release plan that can be read at a glance, with no dates as long as the team has estimated nothing.
The sixth step feeds the first band back into the backlog: each card becomes a user story with its acceptance criteria, written by the product owner with the team. The map, for its part, stays on display. It is used to place each story in the journey, to show what has been delivered and to position a new request.
When several teams contribute to the same product, the map is shared by them. The release bands serve as input to collective planning, and reading by column can reveal dependencies between teams early on. Our agile at scale support deals with this synchronisation; in the SAFe framework, joint planning is called PI planning, presented in our entry on the definition of SAFe.
The end-of-workshop checklist
Before closing the session, go through the map with the group, point by point:
- each activity in the backbone has at least one card in the first band;
- the first band can be told end to end, with no missing step, for a designated type of user;
- each band carries an expected result and the way of verifying it;
- each open question has an owner and a date for an answer;
- the map has an owner, who will keep it up to date, and a place where the team can see it.