What is the difference between requirements, use-cases and User Stories? I’ve been struggling with that question a lot. On one hand it is easy. It’s something completely different. On the other hand, that’s not anything which would help people to understand the difference on their way to implement Agile.
After some time working as Agile Coach, I created this Product Owner development model. It’s focused on product creation and Backlog item definition process.
Level one: User Story is just a special format of a sentence
At this basic level of understanding we are very close to the requirement-like specification. We keep the backlog in the Word document, as we anyway wrote very long sentences and extensive document chapters about the functionality. There is often huge mix of current functionality we want to keep, and new functions. The only change we do with that requirement document is to change/add User Story sentence instead of general name. So we get something like “As a MyCompany, I want new tariff, so that my customers are happier” followed by 2 pages long text description what the “tariff” exactly means. Such User Story may survive at team board for several Sprints without getting done. Surprising, isn’t it? We wrote User Story and it didn’t help!
So this stage is about documents. We create PowerPoint presentations to describe product goals and vision, we use complex roadmaps to define timeframe and we have written long specification documents to describe functionality. The more we write, the better product we have. The understanding of the role of Product Owner is very limited, decisions are often taken as a board of people without real product success responsibility.
Level two: We have ‘bigger fish to fry’, than write User Stories
At this stage we already understand that we have to describe our User Stories better. The team needs higher granularity and detail. But we don’t have time to write User Stories, so that we delegate that unimportant work to some administrative position called business analyst, business requirement specialist, business delivery manager, development team or whoever else is around. We don’t have a time to write such ‘technical’ details. It’s not important for us. Just make sure you will deliver it on time. We have bigger fish to fry. We have to talk to the customer. It’s more than enough to discuss our product ideas and high-level visions. We are responsible for Backlog, and yes, we prioritize it. However, the level of Epics is just about the right level of details.
So this stage is about big high-level decisions and quantity. We already have a Product Owner position, although that person is not often seen. Instead we have the army of people, who are willing to help official Product Owner with creating as many User Stories as you can imagine. What if we need that functionality in the future? Let’s describe all we can possibly do. And if we cover any potential functionality, it must be successful.
Level three: User Story is use-case
Here we finally got it. It’s about functionality slice, it should be INVEST. We have to make it concrete, understandable, and testable end to end functionality. Isn’t that easy? It’s like a use-case, isn’t it? Well, unfortunately, sorry to say that, no. There is a huge difference between use-case and User Story. So what’s the difference? Use-case is end to end functionality which defines what user does and how he is using the product, while the User Story defines only a new/changed functionality. We don’t repeat the current functions anymore and we focus on the changes only.
This stage is already user focused. We start describing different roles. We focus on functionality end to end. However, it’s still not simple and not clear enough. And it’s still not what we expect from the Product Owner.
Level four: We will design one big User Story and copy-paste the rest
This stage looks already pretty good. We have understood that every User Story has three parts – Who, What, and Why, and we think about all three of them. However, we haven’t still understood that every single User Story has its unique value, and it makes sense to invest an energy into individual detail User Story creation process. We are now spending energy describing Super User Stories (smaller and much more concrete pieces than Epics are, although nor small enough to be done in one Sprint yet.) We have great tools, which unfortunately offer a copy-paste feature. So we heavily use it to save our time.
This stage is about User Stories which already create some picture in your head once you read or hear them, but they are very similar to each other and hard to be recognized. We already have spent some time to investigate reasons ‘why’ for bigger chunks of functionality, and we are very happy about it, so we use it at every detail User Story which we create from it – just copy and paste.
Step five: Understand of business value and impact
Finally, we understand that it is worth of investing our time to every single User Story. And we are even looking at it more than once. We reprioritize individual User Stories and not only big Epics. Every User Story has a special role or persona. We have spent time and energy defining every one of them. We encourage ourselves to throw away or postpone User Stories already written, if they don’t match our product/release charter (vision, goals, success measures, timeframe).
We focus on business value and “maximizing work not done” which is one of the core Agile Manifesto twelve principles. We keep our product simple. We try to visualize business value for every User Story in the “Why” part of the formula, so that it helps us to decide on Backlog priorities.
Furthermore, we compare every new User Story with product/release charter and discuss how that User Story contributes to the defined goals and vision. Before we write the complete functionality, we try to measure impact, i.e. if the goal of Epic1 is to limit the traffic through the component A, than individual User Stories may propose different solutions how to filter that traffic out. In traditional management we finish most of them if not completely all. In this stage of this model, we try first to measure the impact by identifying of the percentage of possibly filtered traffic by each solution proposed. And then implement just the ones which have real impact with respect of our goal to limit the traffic. We may identify many great ideas, but we stop implementing as soon as the goal is achieved. At that time we don’t need any other functionality and we can move on to the next important area.
This final Product Owner Development model stage is about business value and impact. The less is more. Product Owner is feeling strong ownership and responsibility over the Product Backlog and individual User Stories. There might be people to help him as Product Owners rarely works alone, nevertheless he understands the importance of his role in defining even the small functional slices as User Stories are. Finally, in this stage the Product Owner is here to shrink possible functionality to the minimum which brings just enough business value. Product Owner must negotiate the functionality and focus more on understanding the customer real needs than all their wishes to come true.
To summarize it, Product Owner Development model is useful tool which helps you to understand where you are with your Agile Product management and product ownership. It also shows you the way where you shall continue and which areas you shall focus. Theoretically you don’t have to go through this model one by one, but it is very likely you will pass all next layers from the one where you are now even if you stay at that one just a very short time.