Agile User Story Slicing – An Alternative to the Vertical Slicing Metaphor for Valuable User Stories

Vertical slicing is a decent metaphor for how to ensure that User Stories are indeed valuable to users and key stakeholders. However, I’ve found it a little bit lacking for more complex systems, especially ones that also have upstream and downstream systems that the system under development interacts with. Cases where this model is especially useful is if your Scrum Team is doing internal software, /System Integration, Business Intelligence/Analytics, and web services(ReST, SOA, etc) or Microservices. Typical User Story practice encourages us to /create stories with INVEST qualities. The practices below will help you do so, and help you connect better with the “V” part of the story, the part that means that story is Valuable to users and /key stakeholders. It will also help you with the other letters in that acronym too. But we’ll focus on the V.

Rather than rely on the vertical slicing metaphor, I’m starting to teach more and more of my coaching and training clients the “System Boundary” view of story slicing. In this model, I tell them to draw a line around their system, and then consider the system boundaries, labeled SB1-SB4 below.

System requirements are best captured at the system boundary. As such, User Story Acceptance Criteria (and indeed their associated Acceptance Tests that are preferably automated) should document what happens at the system boundary, and no further.

Some Anti-Patterns
For instance, in my coaching travels, I have seen people creating “Analysis Stories”,”Technical Stories”, “Testing Stories”, “Back End Stories”, and “Integration Stories.” Nearly always, these are people who struggle with how to “slice the cake” to design a User Story that is truly Valuable, as in the INVEST acronym.

Sometimes, a team is very limited by the stories they can create because they are a component team, and are not able to create an end to end feature like feature teams can. In scaled Scrum implementations(several teams working on the same product/system), some organizations have remnants of waterfall still in their organizational design and team structure, such as a large organization composed almost exclusively of component teams. It’s important to keep an eye out for this “too many component teams” anti-pattern — it can be quite devastating to productivity and value delivery.
For more info see “WODA” in this article about the Top 10 Challenges to Scrum that Organizations face. But with that caveat out of the way…

Great Agile User Stories will hit the system boundaries at least TWICE!

The boundaries of the system(or product, as we say in Scrum) under development are shown in the graphic above. SB1-SB4 represent the system boundaries, where we interface with our key stakeholders (humans, as well as upstream and downstream systems, who have humans that represents the interests of those systems). A good Agile User story will hit those boundaries twice. For instance, the typical “vertical slice” in a typical software application with a GUI will hit system boundaries SB3 and SB4. Sometimes, upstream data will somehow get surfaced in one of a product’s GUIs — so it will hit system boundaries SB1 and SB4.

Example: System Integration (Vendor sold product that your org integrates into it’s internal systems)

Another example might even hit all 4 boundaries! These are pretty typical with /Scrum Teams that do System Integration. Some data could flow in from an upstream system(SB1), be presented in a product’s GUI(SB4) for some sort of approval or tweaking(SB3), then approved and sent to the downstream system(SB4). (But of course, this might be better split into 2 stories that each hit 2 boundaries each)

Example: Web Services

It’s important to note that in this model, the upstream system and downstream system could be the same system. Imagine your product is a back end payment system for a retail web site, and that your back end system had no real GUI, just web service endpoints (ReST, SOA, etc). In that case, the “upstream” system would send a payment service request to your system(SB1), and then your system would do some processing on it, and send it back to the (now considered) “downstream” system (SB2) with an approval or denial code or similar. Note that the upstream/downstream system might be in your org, or it might be external (what web services is really built for). It’s again important to note that if you have /”back end stories”, you probably have component teams. Again, not all component teams are evil, but having too many of them in your organization is pretty damaging in terms of agility and productivity. See “WODA” in this article about the Top 10 Challenges to Scrum that Organizations face.

One other related note is that if you’re implementing Scrum, the people that represent those upstream and to downstream systems(usually Dev Team members of those teams) should be involved in your Product Backlog Refinement and Sprint Reviews, so that they can collaborate about boundaries SB1 and SB2. In essence, these Dev Team members for the upstream/downstream systems are key stakeholders for your system.

In Summary
So, if your User Stories don’t touch the system boundaries at least twice, then strongly question whether you have sliced your story correctly to have “value” or not. Chances are, you haven’t — so look at other ways of slicing and dicing that User Story(see the links below for more help with slicing).

3 Responses

  1. […] End stories also mix nicely with this non traditional Agile User Story slicing model, as usually your system acts as both a downstream(request) and an upstream(response) […]

  2. Interesting article – do you have an example of how you have written one? The web service back end payment system for example?

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

%d bloggers like this: