It is common for teams to struggle with writing user stories that clearly communicate things such as:
The process of user story elaboration is where teams have a shared understanding of what things they need to include in each user story.
The benefits of elaborating user stories based on a known and repeatable pattern include improved understanding of:
Teams can benefit from spending time on story elaboration at any time. The situations in which story elaboration is most common include:
Note: There is a common misconception that the sole responsibility for writing user stories rests with a Product Owner (or a proxy for the Product Owner). Although it is common for Product Owners to draft user stories, it is important for team members to be involved with writing and refining user stories, because when the team is engaged in this activity, it improves the likelihood that everyone has the same understanding of what is to be built, why it is to be built, and how we know when it’s done.
To have a successful story elaboration conversation, it’s important to have:
Let’s start by describing components of “well-articulated user stories.”
Individual sections follow on each of the main components of a well-articulated user story:
Just as is the case with other types of titles (aka headers), a story title should be short, because short statements …
Note: The story title maps to the “Summary” field in Jira.
The following format is recommended for story titles:
<role> <action> [<context>]
Primary applicant enters passcode
<role> = Primary applicant
<action> = enters passcode
Note: <role> and <action> are required, whereas <context> is optional in the title. For instance, when there are many user stories with similar titles, the addition of context can help distinguish between them. In the example above, perhaps it will be possible for the user to enter a passcode in different places in the application being built, or perhaps there is more than one kind of passcode. In such cases, adding context could add clarity, such as “Primary applicant enters passcode on <page type>, or Primary applicant enters passcode <type of passcode>.
The canonical format for a story description is as described below. Here are some things to keep in mind when writing the story description.
Note: The story description maps to the Description field in Jira.
The canonical format for a story description is
As a <role/persona/user type>
I want <goal or action>
So that <desired result from goal/action>
As a primary applicant
I want to enter the passcode I received from my representative
So that I can access my benefit request and verify the information
The priority of a user story is reflected by its relative position in the Product Backlog, and by its relative position in the Sprint Backlog (user stories closest to the top of the list have the highest priority).
Note: The Jira Priority field provides many additional options that can indicate relative importance of any given work item. This cheat sheet does not cover usage of the Jira Priority field.
When Agile teams estimate size, they employ “relative estimation.” It’s called relative estimation because we focus on the relative size of thing A relative to thing B, thing B relative to thing C, and so on.
Note: For a particularly rapid estimation technique, see Affinity Estimation.
For teams that use story points to estimate, it is most common to only use numbers that are part of the Fibonnaci Sequence for story point estimates: 1, 2, 3, 5, 8, 13 …
As anyone who has spent any time building software can attest, it is a difficult proposition to precisely estimate the size of anything we build, and the larger the size of the batch (be it a feature, or a release), the greater the uncertainty and the risk. (Keeping batch size small helps minimize both complexity and risk.)
It has become popular to use the Fibonacci sequence because doing so reinforces the notion that estimates are never exact. For instance, when we consider a user story that has been sized as a 3-point story, and a user story that has been sized as a 5-point story, all we can say with any level of certainty is that based on what we know right now, it will be more work to complete the 5-point story than it will to complete the 3-point story. (By way of comparison, if we are looking at a 3-point story and a 6-point story, it’s more likely we’ll fall into the trap where we assume the 6-point story is exactly twice as big as the 3-point story).
Another appealing aspect of using the Fibonacci sequence is that the bigger the numbers get, the larger the gap between them, which serves as an indicator that uncertainty and risk tend to increase rapidly as work items get larger.
For any user story to be considered Done, it needs to satisfy its Acceptance Criteria, AND it needs to align with any global provisions that exist in a Definition of Done.
A simple way to articulate the purpose of Acceptance Criteria is this: Acceptance Criteria guide the testing strategy, enabling us to demonstrate (via tests) that the user story achieves what it is intended to achieve.
Note: Acceptance Criteria often do not map directly to a particular field in Jira (depending on how Jira is configured). A couple of examples of ways to include Acceptance Criteria in Jira include:
There are multiple ways to write Acceptance Criteria.
Note: For the purposes of this Play, we only describe the “Test that… ” format for Acceptance Criteria, which has the simplest syntax. Test that …
Here are several examples of tests written in the Test that … format:
AT-1. Test that when a user enters an incorrect old password, they get an error message indicating incorrect credentials
AT-2. Test that three incorrect submissions of the old password within 1 hour results in the user being logged out from the system
AT-3. Test that the order confirmation contains:
In contrast with the story headline and story description, which focus on the who, what, and why, the technical approach (in conjunction with the Acceptance Criteria) focuses on how.
Note: In general, artifacts that fall under the technical approach map to Jira as attachments, links, or Sub-tasks.
Because the technical approach can vary significantly, depending on the product, it is difficult to specify a particular format for the story technical approach. Here are some general guidelines:
Note: Jira (and many other tools) support the practice of entering time (typically in hours) associated with tasks. A large number of Agile practitioners consider the entry of task duration (i.e., “burning down” the hours) as a form of waste. In other words, the most important thing to focus on is task completion, not on spending time specifying that a particular task is half-done about lunch time, and three-quarters done at the end of the work day.