Home > Articles > Software Development & Management > Agile

  • Print
  • + Share This
This chapter is from the book

Transparent and Continuous Planning

Lean-Agile release planning is a continuous activity that the entire organization can observe. This makes it possible for anyone to contribute to discussions about the value of items in the plan and the effort required to produce them. Release plans enable delivery in small, end-to-end slices. This enables validation in a regular, predictable rhythm that is defined by the iteration length. As we described in chapter 4, Lean Portfolio Management, we want the product portfolio to serve as the transparent focal point for the business to sequence releases of minimal marketable features.

In all but the simplest cases, a feature requires several iterations before it is ready to be released to the customer. Reasons for this include

  • The feature is too big to finish in one iteration.
  • Multiple features may need to be released together in one package.
  • The customer can only "consume," or put to use, features at a certain pace or at a certain time of year.
  • Marketing, training, support, and packaging for an otherwise completed feature will not be ready after a single iteration.

Release planning must account for all of these when developing the release schedule.

We think of release planning as continuously decomposing a product vision while focusing on those features of greater priority (value) to the business. This decomposition uses just-in-time methods to prevent wasted effort on lower-priority or unneeded features. That is, we expand on features just as much as we need to according to our expectations of when we will build them (this order is determined by the value they provide to the customer). This plan enables the team to look ahead responsibly so that large-effort activities can be broken down in small enough segments (right-sized work) and balanced against higher priority items that come up. A good release plan provides a clear visual control and obviates the need to look too far ahead and work too far in advance on future, larger features. The continuous activity model is shown in Figure 7.1.

Figure 7.1

Figure 7.1 The continuous activities involved in release planning

Release planning starts with a vision provided by the product champion, who can make decisions regarding value priority for both the customer and the business. We typically look to the organization that creates project charters to find ideal candidates for this role. The vision should be reviewed and understood by the delivery team and should be revisited as market conditions change priorities. The vision should be visible (for example, with posters on walls) and re-reviewed as part of every iteration's planning session.

Target dates are determined by looking at the estimates in relation to the team's velocity. For example, if a team can deliver 40 story points in a two-week iteration and we have 200 story points to achieve, we can fairly estimate that it will take five two-week iterations to complete the work at hand. Short cycle times (one to four weeks) enable quick feedback on both the rate of completion and how well we are meeting our customers' needs. During each iteration, teams must focus on coding only the most important feature at any one time. This provides a clear picture of business value (features) juxtaposed against system constraints (technical stories) and enables high-value decisions regarding minimum releasable features.

A project charter should make a business case for new capabilities or capability enhancements. We look to these capabilities to find business features, or "features." It is important to realize that features derive from the vision and capabilities; they do not appear by aggregating lower-level requirements into larger chunks, which is sometimes suggested in the literature as the creation of "epics." Trading business value against effort in search of minimum marketable features leads to decomposing capabilities to form features and stories.

To perform Lean-Agile release planning effectively, the development organization must visually establish (and continuously improve) its ability to determine velocity (story points per iteration), as described in chapter 4, Lean Portfolio Management. The visible velocity is a powerful measure of enterprise capacity (see Figure 4.13 on page 69). This approach requires that the delivery organization be skilled in the art of three-level story point estimation (feature, story, task). Here is another opportunity to emphasize the importance of short cycle time (two-week iterations): The organization is able to recalibrate the quantity associated with story points, as well as get feedback and institutional learning regarding how complex the capabilities, stories, and tasks are.

These multiple levels of continuous decomposition enable an organization to provide estimates required for creating a visible release plan predictably and fearlessly. This is especially worth noting when estimates are required at the feature level, when the least amount of information is known. Experienced Agile teams are confident in providing estimates because the precision required for large features is low, and they know that they are required to commit only when features have been broken down at least two more levels (stories and tasks), and then only commit to two-week iterations with known tasks (which should be about four hours in size). In a transition to Lean-Agile, allow three to four iterations for this skill to mature well enough to produce reliable release plans. Table 7.1 shows the various levels of requirements, their sources, and estimation units.

Table 7.1. Various Levels of Top-Down Requirements Utilized in the Lean-Agile Approach

Requirement Level

Description

Source

Units

Feature

Business solution, capability or enhancement that ultimately provides value to the business and/or its customers

Business/customer value, charter document, business case

Story Points

User Story

Describes interaction of users with the system

Feature

Story Points

Story

Any requirement that is not a user story (e.g., technical enabling, analysis, reminder to have conversation)

Development team, analysis work, large story decomposition

Story Points

Task

Fundamental unit of work that must be completed to make progress on a story

Development team (during iteration planning)

Hours

The rate at which teams complete features can be measured in average story points completed per iteration. This provides a velocity of production. After a few iterations this should converge to a somewhat steady rate. If it doesn't, the teams need to investigate why it hasn't yet happened. Once a reasonable velocity is established, it can be used to estimate delivery dates of the releases. Prior to this, release planning will need to rely on comparing current work to the amount of time it took to perform similar work in the past.

In practice, it is never possible to focus on only one feature at a time. Some features may require longer lead times due to dependencies and waiting to complete system-enabling work. WIP should be constrained by an overall focus on the delivery of features (as opposed to the completion of tasks). The constraint is naturally held to because the visual control would quickly expose a feature that is too large. The mature organization continuously challenges the need for large features to find the minimum scope required to deliver maximum return. Metaphorically, this means that sometimes the business value requires only a "bicycle," while the development organization is creating a "motorcycle." In organizations that exhibit enterprise Agility, visible release plans serve as catalysts for communication, where business value and technical constraints are continuously decomposed and visible along with multiple options based on effort and value. The end result is an organization that incrementally demonstrates and evaluates the value of the release, one feature at a time. A business develops true Agility when it can make real-time verification that what it has built meets the minimum scope required for the feature to deliver its intended value. This is achieved by continuously fighting the waste that comes from building too much. The resulting increase in speed of delivery now enables the organization to meet the demands of rapidly changing markets, customer needs, and business opportunities.

Depending on the release structure of the organization, dedicated release iterations may be required to actually deploy the product to the enterprise production environment. It is an acceptable practice to have a so-called "release iteration" for this activity. It is important that this iteration is constrained to the minimum amount of time required by the release organization, and it should be used only to perform activities required for sign-off and compliance of the release acceptance organization (no new scope).

Releases and Elevations

In an ideal world we could release straight to the customers after every iteration. Unfortunately, for many reasons this is often impractical. For example, if you are on a team that builds embedded software, you may need to create an internal release for the integration team (a team that tests your software, and possibly others' as well) on a hardware platform. Or you may build code that another team will use, so you'll need to release it internally to the other team. There are also times you'll need to release code to selected customers to get feedback—possibly as an alpha test, but maybe just to play with.

We have coined the term "elevation" for all of these "releases" that are not quite real. We don't use "internal release," as elevations sometimes go to customers, but they are not the real releases.

  • + Share This
  • 🔖 Save To Your Account