User Stories | 10 Tips For Writing Good User Stories

10 Tips For Writing Good User Stories
Roman Pichler | Mar 07, 2022 (Update)

1 Users Come First
2 Use Personas to Discover the Right Stories
3 Create Stories Collaboratively
4 Keep your Stories Simple and Concise
As <persona>,
I want <what?>
so that <why?>.

5 Start with Epics
6 Refine the Stories until They are Ready
7 Add Acceptance Criteria
8 Use (Paper) Cards
9 Keep your Stories Visible and Accessible
10 Don’t Solely Rely on User Stories

Author = Roman Pichler

URL = https://www.romanpichler.com/blog/10-tips-writing-good-user-stories/

User Stories | Acceptance Criteria

Acceptance Criteria for User Stories: Purposes, Formats, Examples, and Best Practices
altexsoft | May 18, 2021

What are the acceptance criteria and their role in projects?
Acceptance criteria (AC) are the conditions that a software product must meet to be accepted by a user, a customer, or other systems
. They are unique for each user story and define the feature behavior from the end-user’s perspective.
Acceptance criteria are the lowest-level functional requirements
Well-written acceptance criteria help avoid unexpected results in the end of a development stage and ensure that all stakeholders and users are satisfied with what they get.
An important aspect in regard to acceptance criteria is that they have to be defined before the development team starts working on a particular user story. Otherwise, there’s a decent chance the deliverables won’t meet the needs and expectations of a client.

Acceptance criteria main purposes
Making the feature scope more detailed
Describing negative scenarios
Setting communication
Streamlining acceptance testing
Conducting feature evaluations

Acceptance criteria types and structures:

(A) Scenario-oriented acceptance criteria (GWT)
As the name suggests, the scenario-oriented format is the acceptance criteria type that comes in the scenario form and illustrates each criterion. It is approached through the Given/When/Then (GWT) sequence that looks like this:
Given some precondition
When I do some action
Then I expect some result

The acceptance criteria template in this format includes the following statements:
Scenario – the name for the behavior that will be described
Given (a precondition) – the beginning state of the scenario
When (something happens) – the specific action that the user makes
Then (this the result) – the outcome of the action in “When”
And – used to continue any of three previous statements
When combined, these statements cover all actions that a user takes to complete a task and experience the outcome.

Example – User story: As a user, I want to be able to recover the password to my account, so that I will be able to access my account in case I forgot the password.
Scenario: Forgot password
Given: The user navigates to the login page
When: The user selects option
And: Enters a valid email to receive a link for password recovery
Then: The system sends the link to the entered email
Given: The user receives the link via the email
When: The user navigates through the link received in the email
Then: The system enables the user to set a new password

(B) Rule-oriented acceptance criteria format
The rule-oriented form entails that there is a set of rules that describe the behavior of a system. Based on these rules, you can draw specific scenarios
.
Usually, criteria composed using this form look like a simple bullet list.

Example – User story: As a user, I want to use a search field to type a city, name, or street, so that I could find matching hotel options.
Basic search interface acceptance criteria :
The search field is placed on the top bar
Search starts once the user clicks “Search”
The field contains a placeholder with a grey-colored text: “Where are you going?”
The placeholder disappears once the user starts typing
Search is performed if a user types in a city, hotel name, street, or all combined
Search is in English, French, German, and Ukrainian
The user can’t type more than 200 symbols
The search doesn’t support special symbols (characters). If the user has typed a special symbol, show the warning message: “Search input cannot contain special symbols.”

Ready-to-use acceptance criteria templates

Roles responsible and how acceptance criteria are created
Some of the criteria are defined and written by the product owner when he or she creates the product backlog. And the others can be further specified by the team during user stories discussions after sprint planning.
There are no strict recommendations to choosing the person responsible for writing the criteria. The client can document them if he or she has ample technical and product documentation knowledge. In this case, the client negotiates the criteria with the team to avoid mutual misunderstandings. Otherwise, the criteria are created by a product owner, business analyst, requirements analyst, or a project manager.

Main challenges and best practices of writing acceptance criteria
Document criteria before development.
Don’t make AC too narrow.
Keep your criteria achievable.
Keep AC measurable and not too broad.
Avoid technical details.
Reach consensus.
Write testable AC.

Follow these tips for guidance on how to phrase your AC.
Write in active voice, first-person.
Avoid negative sentences.
Write simple, concise sentences.

Final word
Don’t neglect the acceptance criteria as they – being simple and approachable – solve multiple problems at once. They document customer expectations, provide an end-user perspective, clarify requirements, prevent ambiguity, and eventually help quality assurance verify if the development goals were met. Regardless of whether you use Agile methods or not, make sure to choose the best format or experiment with your own ones. Different types of user stories and eventually features may require different formats and testing the new ones that work for you is a good practice.

Author = altexsoft

URL = https://www.altexsoft.com/blog/business/acceptance-criteria-purposes-formats-and-best-practices/

User Stories | User Stories & Epics

How to Write Epics and User Stories
Nov 16, 2018

Epics

As a product manager/owner while creating an epic include the following four things as the very basic structure.
Introduction
Product requirement
Technical requirement
Design requirement

Introduction
In short, your introduction can include:
summary of what the features you’re building are for and why you’re building them
what metrics you are trying to improve
links to specific documentation
marketing plans, legal requirements (if any)
early wireframes

Product requirement
An essential part of the epic where you provide with an explanation for the whole team working on it to understand what are they going to design, build, test or release. For example, if you are building a feature that the feature has to be fast or should be available in multiple languages, or should work on multiple devices like mobile, tablet and desktop should be mentioned in the product requirement section of your epic.

Design requirement
While writing the design requirement collaborate with your UX designer as much as you can. Take their input as there might be things that a designer thinks is important in order to have a better user experience which wouldn’t cross your mind. For example, a designer might think the preview should be of a certain size and the profile picture should always maintain certain resolution in order for a good experience than those kinds of requirement should be written here.

Technical requirement
Similar to the design requirement in this part of the epic try to involve the engineers or tech lead as much as possible. Their inputs in the early stage will be very useful while estimation and building it correctly. For example, the engineering team might want to build an API to integrate with some other system in order to fetch and maintain the quality of an image, those kinds of specifications and requirements should be mentioned under engineering requirements.

User Stories

User stories are basically the break down of an epic in a more user-focused way for the engineering team to understand the product requirement. In agile methodologies, everything that we build should be focused around users and hence the main purpose of the user story should be to shift the focus around a feature in a more human conversation manner.

Here is a simple template that is widely used while creating user stories:
As a (type of user), I want (some goal), so that (reason).

The point of the user story is to clearly state the feature desired from the point of view of the user.
A user story must have just the right level of detail. It should be a high-level requirement with additional detail added to the accustomed acceptance criteria.
The acceptance criteria are the clear picture for the engineering team to understand ‘what’ they are building and for the QA to clearly state the acceptance test.
The components to be included are:
User story
Acceptance Criteria
Design attached to the user story

Author = Bindiya Thakkar

URL = https://productcoalition.com/how-to-write-epics-and-user-stories-best-practice-1de5b983900

Acceptance Criteria: Purposes, Formats, and Best Practices

AC = Acceptance Criteria = the conditions that a software product must meet to be accepted by a user, a customer, or other system. They are unique for each user story and define the feature behavior from the end-user’s perspective. Well-written acceptance criteria help avoid unexpected results in the end of a development stage and ensure that all stakeholders and users are satisfied with what they get.

Acceptance criteria main purposes
Feature scope detalization
Describing negative scenarios
Setting communication
Streamlining acceptance testing
Feature estimation

Acceptance criteria types and structures
scenario-oriented (Given/When/Then)
rule-oriented (checklist)
custom formats

Scenario-oriented acceptance criteria
Given some precondition
When I do some action
Then I expect some result

This approach was inherited from behavior-driven development (BDD) and provides a consistent structure that helps testers define when to begin and end testing a particular feature. It also reduces the time spent on writing test cases as the behavior of the system is described upfront.
Each acceptance criteria written in this format has the following statements:
Scenario — the name for the behavior that will be described
Given — the beginning state of the scenario
When — specific action that the user makes
Then — the outcome of the action in “When”
And — used to continue any of three previous statements

Rule-oriented acceptance criteria format
The rule-oriented form entails that there is a set of rules that describe the behavior of a system. Based on these rules, you can draw specific scenarios.

Article gives many examples and also covers:
Basic search interface acceptance criteria
Other formats
Roles responsible and how acceptance criteria are created

Main challenges and best practices of writing acceptance criteria
Document criteria before development
Don’t make AC too narrow
Keep your criteria achievable
Keep AC measurable and not too broad
Avoid technical details
Reach consensus
Write testable AC

Author = AltexSoft Inc (Medium)

https://medium.com/@AltexSoft/acceptance-criteria-purposes-formats-and-best-practices-d5fe25e1cd19

8 steps to a Definition of Done in Jira

DoD = Definition of Done = a clear and concise list of requirements that software must adhere to for the team to call it complete.

8 steps to a Definition of Done in Jira

  1. Create a DoD in Jira
  2. Break it down
  3. Make it Global
  4. Manage it over time
  5. (No 5)
  6. Make the product owner responsible and the team accountable
  7. Enforce it
  8. Create an acceptance criteria list in Jira

Author = Dave Meyer (Atlassian)

https://www.atlassian.com/blog/jira-software/8-steps-to-a-definition-of-done-in-jira

Definition of Done Examples for Software Projects

DOD = Definition of Done = a checklist of features and activities, for example, writing code, coding comments, unit testing, integration testing, release notes, design documents, etc. that adds or demonstrates value to the product.

Article covers:
Definition of Done Examples
Definition of Done Examples for each type of DoD

  1. Definition of Done checklist for User Story
  2. Definition of Done checklist for Sprint
  3. Definition of Done checklist for Release

Author = Ekaterina Novoseltseva (Apiumhub)

https://apiumhub.com/tech-blog-barcelona/definition-of-done-examples-software-projects/

Definition of Done vs Acceptance Criteria

DoD = Definition of Done  = a list of requirements that a user story must adhere to for the team to call it complete.

Acceptance Criteria of a User Story = set of Test Scenarios that are to be met to confirm that the software is working as expected.

Article covers:

Definition of Done
The goals of Definition of Done
Example – Definition of Done
Acceptance Criteria
The goals of Acceptance Criteria
Example – Acceptance Criteria
Example of User Story with Acceptance Criteria

Author = Visual Paradigm

https://www.visual-paradigm.com/scrum/definition-of-done-vs-acceptance-criteria/