originally by Michael Mahlberg on agile-aspects
Is the user story overrated? Some story patterns and formats to learn from
The term “User Story” or simply “Story” as a shorthand for a requirement has become quite widespread these days. But what does it actually mean and how can we benefit best from it?
We all know, what a story is, don’t we?
Let’s try this one on, for size:
“Once upon a time, there was… here goes the story … ever after”
That’s the kind of story that most people in the real world think about, when they hear the term “story.”
In the agile realm stories seem to be a different kind of beast
As I point out below, my personal recommendation is something quite different, but in the realm of Agile, stories seem to be something other than in the rest of the world. Within the realm of Agile, the majority of people seem to believe that the “requirements packaged in the form of a story” is the central element that everything revolves around.
That extends so far, that even the “speed” of development teams is (way too) often measured in something called story-points – even though at least one of the potential inventors of the story-point concept says “I […]may have invented story points, and if I did, I’m sorry now.”
And almost everyone in that realm, as well as in its adjacent territories, have –at one time or the other– heard the stipulation that a well-crafted story
- starts with “As a <role>…”,
- has an important “…I want <System behavior>…” in the middle
- and –in the better cases– ends with “…so that <desired business effect>.”
So – why is this incarnation of the concept “story” so prevalent in the realm of Agile? And is it really the best way to handle requirements in contemporary endeavors? To write better stories today, we need to have a look at how stories came to be such an important instrument in the realm of “Agile Software Development”1 in the first place.
How stories came to software development
Back in the day, before the “Manifesto for Agile Software Development” was written, there were several approaches whose champions called their movement “lightweight software development” and who would later come together and write down what unified their approaches under the moniker “Agile Software Development.” These approaches used all kinds of helpful ways to describe what the system should be able to do.
In Scrum they had the PBI (Product Backlog Item), in Crystal the use case was somewhat prominent, other approaches used comparable artifacts. Extreme Programming was the one that used something called a User Story.
This concept of the user story somehow had such an appeal, that many of the other approaches embraced the idea – more or less.
It was more about the telling, than about the story
A key component behind the idea to use “stories” has even made it into the Manifesto for Agile Software Development – To quote the sixth principle from that manifesto
“The most efficient and effective method of
conveying information to and within a development
team is face-to-face conversation.”
Before the recommendation that requirements should be talked about was written down in that form, it was embodied in ideas like CCC Card – Conversation – Confirmation or the nice quote from the Book XP-Installed from the year 2000 that a card is a promise to have a “series of conversations about the topic.”
Unfortunately, in today’s world the concept of On-site customers often has been reduced to a person who is called Product Owner but doesn’t have any real business authority and spends about two hours with the team every two weeks. Under these circumstances it seems questionable whether this approach to product development is still viable for all cases.
But I am convinced that understanding why it was okay to write only one sentence to represent a complex requirement back in the early days of lightweight methods helps a lot with writing good stories today.
The fact that the way of working that lead to the original user story is hardly feasible in today’s “corporate agile” with all its compromises, has a direct impact here. It implies that we need something more than just the concept of a “User Story” if we want to capture and process requirements in an efficient manner.
Don’t put the story in the center, focus on the value and the work item
What most approaches propose, is some container that represents “value for someone.” In the process framework Scrum this is called Product Backlog Item, in more general approaches –like the Kanban Method– it is often simply called Work Item.
Such a work item –to got with the broader term– can have many structures. A few common attributes of many such item types are:
- Expected value
- “The Actual Requirement”
- Currently responsible person
- Estimated effort (Yes, I really mean effort – as Mike Cohn explains, too)
- Technical risk/complexity (Liz Keogh has some helpful suggestions on that)
- and many more.
Of course, one of the attributes needs to be the actual requirement. And that could be represented by a story. But does that have to be a user story? Actually, there are some pretty helpful alternatives out there.
If you use some kind of story, get to know several types of stories well
As it is often the case, the habitat of the original user story provided many things that were no longer present once the concept was mimicked elsewhere. And as time went by, some people re-discovered what a story could mean for them. Some other people –many, actually– got confused by the story concept since they never really saw it in action and only knew about it through very indirect word of mouth.
After the “As a «role» I want…” format for user stories had been around for quite a while, Liz Keogh pointed out that many of the so called user stories out there are not actual user stories but instead Stakeholder Stories.
- Format of the Stakeholder Story
Liz Keogh described her ideas and observations in the 2010 Article “They’re not User Stories.”
The generic form of this kind of story –the way I use it these days– is
In order to «the required business effect»
«some stakeholder or stakeholder persona»
«wants,need,requires,…» «some kind of system behavior or future state»
- Context for the Stakeholder Story
- This is an extremely useful perspective if you have to describe requirements that are not actually wanted by the end user of the system, or that don’t actually have a direct user interaction.
- Most of the requirements I encounter in enterprise contexts are more stakeholder-driven than user driven. (Legal requirement for example. Something like “To avoid being sued for GDPR violations our CISO requires that we have some GDPR-compliant deletion mechanisms that could be executed at least manually if ever a user actually should file a complaint that conforms to article 17 of the GDPR.”)
- Caveats for the Stakeholder Story
- The stakeholder should be as tangible and concrete as possible. Unlike with the model of personas in user stories for stakeholders in user stories, it is extremely helpful to name a real person for stakeholders in stakeholder-stories.
- What to avoid for the Stakeholder Story
- The most common problem I see with stakeholder stories these days is that the required business effect gets confused mixed up with the system behavior or future state.
It was probably Mike Cohn who popularized the now so common form of user stories in his 2004 and 2005 books “User Stories Applied” and “Agile Estimation and Planning” but to my knowledge Rachel Davies came up with it around 2002 at Connextra (actually that’s also what Mike Cohn’s post about the three part user story tells us)
- Format of the User Story
The now prevalent way to capture user stories is the well known
“As a «role or persona» I want «system behavior» so that «desired business outcome».”
This is described (amongst other sources) in the often quoted Article Why the Three-Part User Story Template Works So Well by Mike Cohn.
- Context for the User Story in this sense
- Helpful if you really have a product (sometimes a project and seldomly a service) that has actual interactions with actual users
- Caveats for the User Story in this sense
- It should describe an interaction between a user and a system that will be possible after the requirements has been implemented.
- What to avoid for the User Story
- A story like “As a team member, I want another team member to implement the database logic for the WhatNotField so that it will be available” is using the format alright, but misses almost all point of using User Stories.
To my knowledge the whole “Jobs to be Done” way of approaching product challenges became popularized through Alex Osterwalder’s work with Strategyzer around the value proposition canvas. [Please let me know, if you know the whole back-story, I’d be really interested in learning about that] Soon after that the JTBD idea proved so powerful that it spawned it’s own community.
- Format of the Job Story
- The article Replacing The User Story With The Job Story describe the idea of the Job Story as separating situation, motivation and expected outcome by using the format
When ________, (the situation part)
I want to ________ (the motivation part)
so I can ________ (the expected outcome part)
- Context for the Job Story
- Good for very young stories, when you still try to figure out what you’re really talking about.
- Caveats for the Job Story
- Unlike Stakeholder Stories and User Stories, Job Stories don’t (yet) provide an easy way to fill out the ________ part, so you really need to dive into the ideas outlined in the above mentioned articles and there can be a lot of discussion about the “right” way to write such a story.
- What to avoid for the Job Story
Of course this only covers some aspects of the usage of stories in todays post-agile society, and I would strongly encourage anyone to look (deeply) into the stuff about INVEST and SMART and at User Story Mapping, to get event more background with regard to working effectively with stories to represent aspects of requirements, but I hope this article gives you some ideas on when and how to use some other kinds of stories to represent requirements that are really hard to fit in the “As a «Role» I want…” format.
till next time