In a previous post, I outlined the rules of Scrum. This post details one of those rules. Picking a most important part of Scrum is difficult. All of the rules are required, but if there were one rule that is “more” required that every other rule, its having a good Product Owner. Simply put, the Product Owner can make or break the project. Duties of the Product Owner A Product Owner has many duties and responsibilities. I’ll talk about each of these duties in detail below. A Product Owner: Discovers and records stories for the backlog. Prioritizes stories in the Product Backlog, Release Backlog and Iteration Backlog. Determines Release dates and Iteration Dates. Develops story details and helps the team understand those details. Helps QA to develop acceptance tests. Interact with the Customer to make sure that the product is meeting the customer’s needs. Discovers and Records Stories for the Backlog When I do Scrum, I always use User Stories as the means for capturing functionality that’s required in the system. Some people will use Use Cases, but the same rule applies. The Product Owner has the ultimate responsibility for figuring out what functionality will be in the system. Many different mechanisms for capturing this input can be used. User interviews are great, but all sources should be considered, including talking with Customer Support types. Often, they hear what users are struggling with the most and are a great source for stories that can make the application easier to use. Care should be taken when soliciting user stories from technical types such as programmers and the people that manage them. They will almost always give stories that are very technical in nature and may not have a direct benefit for the end user. Stories are about adding value to the company. If the stories don’t have direct benefit to the end user, the Product Owner should question whether or not the story should be implemented. In general, technical stories should be included as tasks in User Stories. Technical stories are often needed, but the ultimate value to the user is in user based functionality, so technical stories should be considered nothing more than overhead in providing that user functionality. Until the iteration prior to development, stories should be nothing more than short, one line placeholders. An exercise called Story Planning can be used to brainstorm and come up with stories. I’ll save the description of this activity for another blog post. For more information on User Stories, please read the book User Stories Applied by Mike Cohn. Prioritizes Stories in the Product Backlog, Release Backlog and Iteration Backlog Prioritization of stories is one of the most difficult tasks that a Product Owner must do. A key concept of Scrum done right is the need to have the team working from a single set of prioritized stories. If the team does not have a single set of prioritized stories, Scrum will likely fail at your organization. The Product Owner is the ONLY person who has the responsibility to prioritize that list. The Product Owner must be very diplomatic and sincerely listen to the people around him so that he can get the priorities correct. Just listening will still not yield the proper priorities. Care must also be taken to ensure that Return on Investment is also considered. Ultimately, determining which stories give the most value to the company for the least cost is the most important factor in determining priorities. Product Owners should be willing to look at cold, hard numbers to determine the order for stories. Even when many people want a feature, if that features is costly to develop, it may not have as high of a return on investment as features that are cheaper, but not as popular. The act of prioritization often causes conflict in an environment. Customer Service thinks that feature X is the most important, because it will stop people from calling. Operations thinks that feature Y is the most important, because it will stop servers from crashing. Developers think that feature Z is most important because it will make writing software much easier for them. All of these are useful goals, but the team can have only one list of items, and each item must have a priority that is different from all other stories. The Product Owner will determine which feature gives the best return on investment and the other features will have to wait their turn, which means that someone will not have their top priority feature implemented first. A weak Product Owner will refuse to do prioritization. I’ve heard from multiple Product Owners the following phrase, “Well, it’s all got to be done, so what does it matter what order we do it in?” If your product owner is using this phrase, you need a new Product Owner. Order is VERY important. In Scrum, every release is potentially shippable. If the wrong priority items are developed, then the value added in each release isn’t what it should be. Additionally, the Product Owner with this mindset doesn’t understand Agile. A product is NEVER finished, until the company has decided that it is no longer a going concern and they are no longer going to sell the product. Therefore, prioritization isn’t an event, its something that continues every day. The logical extension of the phrase “It’s all got to be done” is that you will never ship your product, since a product is never “done.” Once stories have been prioritized, assigning them to the Release Backlog and the Iteration Backlog becomes relatively simple. The top priority items are copied into the respective backlogs in order and the task is complete. The team does have the right to shuffle things around a little in the iteration backlog. For example, they may determine that working on story C with story A is appropriate because they’re related, even though story B is technically a higher priority than story C. Or they may decide that story B is too big to complete in the time available after Story A has tasks created, so they’ll work on Story C since it’s smaller. They can’t, however, go deep into the backlog to pick stories to implement. The team and the Product Owner should work together to determine what’s best for the company. Prioritization is time consuming, but its one of the most important things a Product Owner does. Determines Release Dates and Iteration Dates Product owners are responsible for determining release dates for a product. A common misconception that Product Owners have is that every “release” needs to correspond with an actual release to customers. This is not the case. In general, releases should be no more than 3 months long. You may decide to release the product to the customers, and many companies do release the product to customers, but it may also be an internal release. If a release date is too far away, developers will fall into the trap of not feeling a sense of urgency. The date is far enough away that they don’t need to give the release their full attention. Additionally, important tasks, such as performance tuning, regression testing, user documentation, and release preparation, will not happen regularly, making them much more difficult and time consuming to do. The more frequently you do these tasks, the easier they are to accomplish. The Product Owner will be a key participant in determining whether or not a release should be sent out to the customers. The determination should be made on whether or not the features contained in the release are valuable enough and complete enough that the customers will see real value in the release. Often, some features will take more than three months to get them to a state where they qualify for a release or need additional supporting features to be released. The product owner has the right to make this determination. In addition to release dates, the Product Owner also will help determine iteration dates. In general, an iteration length should be chosen and the team should follow that iteration length for an extended period of time. If the iteration length is changed every iteration, you’re not doing Scrum. Iteration lengths help the team and company get into a rhythm of developing quality software. Iterations should be somewhere between 2 and 4 weeks in length. Any shorter, and significant software will likely not be developed. Any longer, and the team won’t feel urgency and planning will become very difficult. Iterations may not be extended during the iteration. Companies where Scrum isn’t really followed will often use this as a strategy to complete all stories. They don’t want to face the harsh reality of what their true performance is, and looking good is more important than seeking visibility and improving the process and team. Companies like this typically don’t allow failure. This is unhealthy. Failure is part of life and unless we learn from it, we can’t improve. I would much rather see a team push out stories to the next iteration and then have healthy discussions about why they failed rather than extend the iteration and not deal with the core problems. If iteration length varies, retrospectives become more difficult. For example, evaluating the performance of the team’s estimation efforts becomes much more difficult if the iteration length varies. Also, the team must have a velocity measurement. If the iteration length varies, measuring velocity becomes impossible and upper management no longer will have the ability to evaluate the teams performance. People external to the team will no longer have the ability to determine when key features are likely to be developed. Variable iterations cause the entire company to fail and likely cause Scrum to fail at an organization. Develops Story Details and Helps the Team Understand Those Details A key concept in Scrum is that the stories are nothing more than a placeholder for a conversation. Stories should be nothing more than short, one line statements about the functionality. The team will then converse with the Product Owner about the details about that story. The product owner needs to have a very good idea about what the details of the story are and needs to be able to help the team understand those details. Too often, we see this requirement as being translated into the need for comprehensive documentation about the story, including old fashioned requirements documentation. The team should only develop the documentation that is required and should not develop documentation that is only created because their is a process to do so. In general, what we see that works best is the iteration before a team starts development work on a story, the Product Owner, with other appropriate business analysts, will develop the details of that story. They’ll figure out what business rules are required, potentially make paper prototypes or other light weight mock-ups, and they seek to understand the story and what is implied. Note that the time allowed for this task is deliberately short. The Product Owner only has a single iteration to develop all of the stories for the next iteration. If more than one iteration is used, I’ve found that teams will end up with Big Design Up Front and traditional requirements documents. This is a waste of time, since the team will need to then have discussions with the Product Owner to figure out what the requirements document says. Instead of this, skip making the pretty pictures and detailing the nuances of the requirements and build only what is minimally needed by the team to do development. If something comes up during development, you can address it at that time and figure out what you want to do. The goal is to keep things as light weight as possible so that everyone can move as quickly as possible. Helps QA to Develop Acceptance Tests In Scrum, no story can be counted until it is accepted by QA. Because of this, acceptance tests are very important to the team. In general, acceptance tests need to be developed prior to the iteration or at the very beginning of the iteration so that the team can make sure that the tasks that they develop will fulfill the acceptance criteria. The Product Owner will help the team, including QA, understand what will make the story acceptable. Note that the Product Owner needs to be careful about specifying that the feature will work “Perfectly” at the end of the iteration. In general, features are developed a little bit at a time, so only the bit that is being developed should be considered as necessary for acceptance. A weak Product Owner will make statements like “Do it right the first time.” Not only are these statements damaging to the team (like they would try to do it WRONG the first time . . .), they’re also ignoring the iterative nature of Scrum. Additionally, a weak product owner will seek to add scope in the acceptance testing. For example, they will refuse to determine acceptance at the beginning of the iteration, and then, after the team has planned and committed to the iteration, they will expand scope by defining acceptance. This often causes the team to miss the iteration because scope that wasn’t planned on is included. There are ways that the team can mitigate this problem. For example, include extra “Product Owner” time to deal with the uncertainty that you know will be introduced by the Product Owner. This will slow the perceived velocity of the team and is not ideal, since they’ll be doing more work than they get credit for. Interact with the Customer to Make Sure that the Product is Meeting the Customer’s Needs Once development is complete, what the team has worked on should be put in front of real live people to see if it meets the needs of the customer. One of the great things about Agile is that if something doesn’t work, we can revisit it in a future iteration! This frees up the team to make the best decision now and know that if that decision proves to be incorrect, the team can revisit it and change that decision. Features are about adding value to the customer, so if the customer doesn’t find them useful, then having the team make tweaks is valuable. In general, most software will be 80 to 90 percent “right” after the initial round and only minor tweaks are required. If proper coding standards are followed, these tweaks are usually minor and easy to accomplish. Product Owners that are doing a good job will encourage real users to see and use the software, since they know that they are trying to add value to the customer. Poor product owners will think that they know the answers already, that their customers are silly and do stupid things and that they don’t need customer input. If you have a product owner that is afraid to show the team’s work to real customers, you probably need a different product owner. Up Next, “Who Makes a Good Product Owner.” Followed by, “Messing with the Team.” Technorati Tags: Scrum,Product Owner
