User story mapping is a very powerful tool by Jeff Patton and I have used it many times in IT context. With a user story map you list the steps of a user journey in your system on top and then list out the details of each of these steps below (see the picture below because this explaination doesn’t really give the tool justice).
This is awesome but one of the things that I always gets hanged up on when doing this is the incremental part of fleshing out the details.
I wanted to share one situaton when we created an user story map for a very non-IT situation and I learned a bit on what incremental means.
Earlier this year my family and I moved to another appartment. As always planning the move is a undertaking of enormous proportions, but I felt that as a agile guy for close to 15 years, I could probably handle it. For some reason user story mapping popped into my head.
It was a bit of a special setup as we had access to the new apartment for about two months before we needed to leave the old apartment. Plenty of time to move, right?
Here’s what we did; on the steps level we listed the rooms in the new apartment. This represents features in a software setting, like sending email, reading email, finding users etc in an email client for example.
Here’s how our user story map looked, there’s a bigger version for your download here, should you want to check the details.
On the top of our board we listed rooms and then below we started to list all the things that should go into each room. The many boxes of toys should go into the boys rooms, where should the beds be, the closest into room a, this chest of drawers into our bedroom etc.
Although this gave us an overview and visibility this still didn’t really help us to plan the move. I was also a bit worried that we would forget to plan where stuff should go with so many moving parts (i.e. boxes) in action.
I started to think about the real gain of the user story mapping - the planning phase. Because once you have listed out all your details, according to the image above, you can now make a horizontal cut for what goes into what release. There’s a trick thought and we will soon come back to that.
For us we made up three small releases, each with more value for us, than the other. Here’s how we named them:
- What do we need to stay one night?
- What do we need to have like a weekend-trip in the new apartment?
- What do we need to live there a full year?
These are all incremental more complex and complete for the whole move, which made sense since we had 2 months to do the move. Now we could split the details/boxes/things to move into smaller incremental versions of the finished rooms.
Here’s one example of what we did:
“What do we need, in the boys room, to stay one night?”, I asked in my best coaching voice.
“Bed and linnen should do it. A lamp at the bed post.”, my wife Elin, replied tired of having to be part of yet another of my experiments that ‘will make a good blog post’
“And a box of toys! Legos”, said the boys that was focusing on the value of the room.
“And what is needed for a full weekend”, I said
“We need clothes, a few changes of them. And more toys, and lamp in the roof”, Elin said.
And like that we fleshed out the details for the incremental versions of the full room.
You can see these incremental “release” of our move, through the different color dividers we made on the board. Everything above the green divider in a column is needed for that version of the completed move, for that room.
Remember the gotcha/catch I told you about when we talked about user story mapping for system developement. Well, this is it. The details have to be in incremental better versions of the full story. A good way is to ask
What is the smallest thing that could possible work.
“Send email, what do we need for that features as the smallest possible that could work?”, the agile coach said, now on his home turf and feeling confident.
“Well… just a textbox for the reciever, sender and a subject line”, said the team that was tired of being featured in a blog post about moving.
“Next level would be a cc-box”, a even more bored team member added as he just wanted out of the post.
I actually found user story mapping really useful and it helped us to think in incremental versions of what should go into each room. We didn’t move like this since we didn’t have ready access to a moving truck for 2 months but it gave us a great overview of what needed to be done.
It also revealed a nice trick for me, by naming the releases we forced ourselves to think about the incremental versions of the finished room. It was easy to understand what needed to go into a room if you only going to stay there one night. From there it was equally easy to add next increment of the finished room until we got the whole thing completed.
We even found out somethings that we had in some rooms that we didn’t need to “live there a full year”. These things we threw out. Or packed away, if it was memorabilia.
When we do user stories maps for software applications I found that naming the releases will help us too. “Only text, to one person only, version”-release of a email client is easy to envision and understand. Now we can easily find the first increments of each step/feature and skip all but the necessary.
Hope you found this story from my personal life interesting.