Lean-Agile Release Planning

This chapter is from the book 

Example: Release Planning Session

This section describes a typical release planning session. Such sessions often follow a sequence like this:

1. Identify features.
2. Prioritize features.
3. Split features using the minimum-marketable-feature perspective.
4. Estimate the value of the features.
5. Estimate the cost of the features.
6. Elaborate further by writing stories for features, repeating until you have reasonable clarity on what the features are and their high-level values.
7. Create a specific release plan by date or by scope.
8. Plan elevations.

How long does a release-planning session take? Small projects (three months or less) can often be done in a day. Larger projects will take a few days.

During the session, the team has to remember constantly that it is being driven by two forces:

• Add value for the customer. The focus is not on building software; it is to increase the value of the software product we create to those who will use it. The software is a means to an end, but it is not the value itself.
• Get to market quickly. Develop plans around minimum marketable features (MMF). View features from the MMF perspective: What is required to develop and release them?

In the following sections, we examine each of the steps in a bit more detail.

1. Identify Features

Begin by writing features on stickies or index cards. Briefly describe each feature (usually just a few words), as shown in Figure 7.2. At this point, the team is just trying to establish a high-level scope of the system.

2. Prioritize Features, Left to Right

Once the features are identified, the team does an initial prioritization: Place the most important features on the left and the least important on the right, as shown in Figure 7.3. This only represents a first cut; the team is not committed to this order. It will certainly change as they work through the steps.

Even this initial prioritization should prompt some interesting conversations. The conversations should focus on sharing knowledge and helping everyone learn more about the features. Don't get hung up on whether the prioritizations are absolutely correct. Focus on learning as much as possible and consider all decisions tentative.

3. Split Features Using the MMF Perspective

Once the initial set of features is described, it is often easy enough to split up some into what could be called minimum marketable features and then further split into one or more enhancements to those MMFs.

For example, suppose Feature F in Figure 7.3 must be supported on five different platforms: Linux, Windows, Solaris, HP, and AIX. Talking with the customer, the team discovers that only Linux and Windows need to be supported at first. Feature F can be broken into two parts: the core MMF for Linux and Windows and an extension MMF for the others. Call these F1 and F2, respectively. Other features can likewise be decomposed, as shown in Figure 7.4.

4. Estimate the Value of Features

Since the product champion is driving from business value, the first thing to do is estimate the relative value of each feature. We can do this using the Team Estimation Game.² The value of each story is assigned business-value "points" (shown as "BV" in Figure 7.5). However, do not reorder the features based just on these points. Features may have to be developed in a particular order or you may need to get a sense of the cost required for each business value.

You may find that you have difficulties quantifying features by points this way. In this case, just identify the general sequence in which the features need to be built. We have found that many organizations cannot initially set values to the core, required features. In some sense, this doesn't matter: They will all need to be built before release anyway. If that is the case, don't worry about it. You should find that, after the release of the core MMFs, you can set relative values for the remaining features.

Remember: Business or customer value is independent of cost. First, determine business or customer value and only then ask the team to estimate the cost. Then, you can calculate ROI.

5. Estimate the Cost of Features

You can use the Team Estimation Game to estimate the cost of the features that are represented in "story points" (shown as "SP" in Figure 7.6).

Once you have the cost for each feature, the product team may decide to reprioritize them. In effect, you now have the capability to evaluate Return (business value) on Investment (cost), which enables new insight into selecting what brings the highest return to the business for the effort spent by the delivery team. A significant value of this technique is that it clearly de-couples business value prioritization from technical effort, which is an opportunity to drive from business value first. We find that most business organizations have lost the ability to prioritize based on business value alone because they are so used to batching up large requirement sets with faraway dates that they see no need to sequence features since "they are all important."

6. Elaborate Features

You might be surprised at how well this approach works at a high level. It works by comparing one item against another—something teams are reasonably good at. Going further requires more accuracy. This requires a more detailed understanding of the features.

Start by writing stories for each of the features, beginning with the higher-priority features, the ones you will be working on sooner. This is called "elaboration."

After elaborating a few features and increasing your understanding of what is required to build them, you may need to re-estimate both business value and cost. (Notice that this technique has a built-in feedback loop that continuously calibrates the accuracy of the feature estimates. The elaborated stories for each feature are individually estimated and then summed to compare with the feature.) Continue this process until you have a set of features comprised of the core and extension MMFs, along with a number of elaborated stories, and you are confident in the relative estimates of the features. This is shown in Figure 7.7.

7. Create the Release Plan

Now the team is ready to plan releases. There are two approaches to this: planning by date and planning by scope. Which to use depends on your needs, which are often mandated by governmental regulations or market conditions.

Planning by Date

There are times when a project must come in by a certain date: Government regulations require certain features by a certain time, software is required for a conference, or our industry requires major releases at a certain time of year. If this is the case, then the release plan entails setting the date and ensuring the right amount of functionality can be achieved within the allotted time.

For example, suppose you have four months to finish product development and every feature except B, F2, and E2 is required by that date. The release plan is shown in Figure 7.8.

Add up the estimated number of story points for these features. That determines how many points must be completed in each iteration. In this example, there are 480 story points. There are 17 weeks available. Suppose Iteration 0 requires a week at the beginning and there are two weeks at the end for alpha testing. That means 480 points over 14 weeks for development, or 34 story points per two-week iteration.

• Total Points/Number of Weeks Available for Development = Required Team Velocity

If the team can handle that level (velocity), that is great. If not, you have to focus on what is truly minimal for each of the identified features. What can be cut out? What must be left in? At the beginning, you cannot know for sure, which is why the focus must be on starting work on only the features, or aspects of features, that are truly essential. Iterative development will enable you to discover the core functionality need.

This type of estimation does not necessarily give you better accuracy than traditional methods. But it does show you where you need to look to make your decisions. Very often it becomes clear that the true MMFs can be built in time, whereas you are uncertain about features you would just like to have. Sometimes, it becomes clear you are in trouble. If you are somewhere in the middle, then at least you have an idea about which features you need to investigate further.

Planning by Scope

Another approach is to plan by scope. This works much like planning by date; however, this time you begin with those MMFs that are required. Calculate the number of story points in the MMFs, divide by the team's velocity (the ability to complete stories in an iteration) and the result is the time required to do the work.

• Total Points/Team Velocity = Number of Weeks Required for Development

If the result is too long, reassess to see what features or elements can be dropped to make it shorter.

Proper Planning Avoids Risk

Both of these approaches help teams focus and avoid risk. They help teams:

• Work on the most important features
• Avoid starting less-important features until the more important ones are finished
• Minimize WIP

These are crucial. Consider a time when you were working on a project only to discover you were going to have to cut scope. The predicament is that at this point, you have:

• Already completed some less-important features—which you started because at the beginning of the project you were confident it was all going to happen; and
• Started some features you would like to cut but doing so now would cause you to lose work you've already done—you'd have wasted time and added complexity for no value (almost certainly the code that's in there for these features will stay in there).

Planning-by-date and planning-by-scope methods help ensure that the team works on the most important features known at the time and that other features are not started until the important ones are finished.

8. Plan the Elevations

There may be another degree of complexity to consider when there is more than one team involved in the software development or there is a subset of the software that can be tested but cannot yet be released.

The first case can be made more difficult if there is hardware on which to test as well. In these cases, an internal release is necessary to test the system—either its technical integrity through integration testing or its quality to customers through external system testing using alpha or beta testers. We call these pseudo/external releases "elevations." We are moving the software farther down the value stream, but not all the way to the customer. We will consider two different types of elevations.

Elevations for Integration Testing

Very often a team will build software must interact with software that other teams are building. You cannot be sure exactly how it will function until the other teams use it. Or teams are creating multiple products that must be used on a hardware platform. Until the software is actually on the hardware, you cannot know for sure how it will function.

One type of elevation planning is to look at the milestones the software must reach prior to true release. In a situation like this it could be

• Software passes a team's functional test.
• Software passes several teams' functional test.
• Software works on a specified hardware platform.
• Software has been alpha-tested by a set of customers.

This example would require three elevations prior to the final release:

1. Move the software to the other teams that will use it.
2. Load and test the software on the hardware platform using internal testers.
3. Enable external users to try out the software.

These elevations are shown graphically in Figure 7.9.

Elevations to Different Platforms

A different elevation pattern exists when the software you are writing must work on different operating systems. For example, suppose you are writing software for Windows, Linux, and mobile platforms. Figure 7.10 illustrates that elevation plan.

Elevation Summary

There are no set rules for elevations. The ideal case is continuous integration across all development. But when different platforms, operating systems, hardware, customer bases, and so on are present, that is not always possible. Elevation planning, however, enables you to investigate the best way to get feedback about a larger, working part of the system. Acceptance Test-Driven Development with an emphasis on design patterns and refactoring enables the organization to benefit holistically from emergent design techniques. For example, skilled organizations that mock to test and refactor to design patterns can do more in-place and continuous integration than would be required to incorporate Lean-Agile in complex-release organizations that deliver across different platforms. Chapter 9, The Role of Quality Assurance in Lean-Agile Software Development, covers this in more detail.