TL;DR: To create a product backlog, “vertically slice” your user stories by grouping similar scenarios. Estimate the work and value of these slices instead of the user story.
I’ve seen a rise in the demand for “full-stack” developers in the last couple years.
The agile concept of “vertical slicing” made these types of positions very popular.
In a traditional team structure, each person on a team will have knowledge of one layer of an application. When the team attempts to complete some feature, they will have to split the feature into tasks corresponding to layers and then distribute the task to the proper people.
We call this “horizontal slicing”.
If you had a team of “full-stack” developers then you could simply assign a feature to a developer and you could expect them to complete the feature end-to-end with little to no help or coordination.
We call this “vertical slicing”.
This works great in theory, but it has a lot of challenges in practice.
One of these challenges is the exact means of creating high quality product backlog with “vertical slices”.
Enter User Stories
I typically see teams create vertical slices based on “User Stories” and the Gherkin syntax.
The following two code snippets provide examples for two fictitious features: (a) Create Account and (b) Login.
Unfortunately, this sometimes creates very large product backlog items that the team can not deliver quickly.
In particular, I’ve seen this happen when the business dictates that teams can only release polished and bug-free features.
For example, it could take a very long time for a team to complete the scenarios “Internal Server Error” and “Wait Too Long” for the feature “Create Account’. Further, those scenarios may not deliver much business value compared to the necessary work.
In comparison, it could take a very short time for a team to complete the scenario “Valid Account Creation”, and that scenario might have very high business value.
This illustrates that coupling all scenarios together can impede the early and frequent releases we need to create a tight feedback loop between developers and testers or users.
Slice Your Slices
User Stories are not bad, though. We just need a better way to generate vertical slices for our product backlog.
Notice that each user story has multiple scenarios, and that we can conceptually break up each user story into individual scenarios.
Based on this principle, we can create vertical slices by grouping scenarios based on business value.
For example, we could slice our features in the following way.
|Create Account||Basic||Valid Account Creation|
|Business Rule Violations||Duplicate Username|
|User Input Errors||Not a Strong Password|
|Passwords Do Not Match|
|System Problems||Long Wait Time|
|Internal Server Error|
|Business Rule Violations 1||Invalid Username/Password|
|Business Rule Violations 2||Too Many Incorrect Attempts|
|System Problems||Long Wait Time|
|Long Wait Time|
Each of these “vertical slices” become product backlog items that we can individually estimate and prioritize.
For example, our fictitious product team could prioritize the “vertical slices” in the following way.
- Create Account – Basic
- Login – Basic
- Login – Business Rule Violations 1
- Create Account – User Input Errors
- Create Account – Business Rule Violations
- Login – Business Rule Violations 2
- Create Account – System Problems
- Login – System Problems
This allows a more granular approach to creating product backlog items.
As an added benefit, you can leave a “user story” largely undefined so long as you already have its highest priority slices within your product backlog.
This allows you to “groom” your user stories in a “just in time” way.
For example, we created 4 “vertical slices” of the feature “Create Account” in the example above. However, as an alternative, we could simply create the first slice “Create Account – Basic” and not bother with further analysis until someone completes that slice. This could have saved everyone from spending unnecessary time in a grooming session.
I am only providing an illustration, though. Ultimately, the end result depends on the situation and the interaction between team members.