Because Disciplined Agile Delivery (DAD) addresses the full delivery lifecycle it explicitly addresses the effort required to transition your solution into production, or in the case of product teams into the marketplace. This transition effort may be referred to as release, deployment, or even the “end game”. For teams relatively new to agile this transition effort is a phase, or if you don’t like the term phase then an iteration which very likely has a different time frame than construction iterations. However, as we indicate in the DAD book, as teams gain more experience with agile and lean techniques the “transition phase” can be evolved into a “transition activity” with a little bit of discipline. That is the focus of this blog posting.
The DAD framework is goal-driven, not prescriptive, and as a result it describes the transition effort in terms of goals:
- Ensure that the solution is ready to deploy. To achieve this goal you will need to address several issues, such as planning the transition effort, verifying that the solution meets the stakeholder needs for the current release, and validating that the solution is of sufficient quality. As with other DAD goals, there are several ways each of these issues can be addressed, each with advantages and disadvantages. There is no single strategy that’s right for all situations.
- Ensure that stakeholders are ready to receive the solution. Similarly, there are several issues you need to consider when addressing this goal, including how you communicate that the release is coming, how to train and educate stakeholders in the new solution, and how to prepare the operations and support environment for the new release (one of the many aspects of a disciplined DevOps strategy built right into DAD).
- Deploy the solution. Issues to consider when achieving this goal is identifying what should be released, how you can back out the release if you run into trouble, and how to determine that the release was successful. The last issue, determining success, isn’t as obvious as you would think. Does success mean that the solution is up and running in production? Or does success mean that you have satisfied, or better yet, delighted stakeholders?
It is straightforward to empirically observe that the complexity of your transition effort can vary depending on the context of your situation. For example, a simple standalone application such as a website can be easily deployed regularly because it effectively involves copying some files to a server (farm). Organizations in this sort of situation may choose to deploy their software many times a day. However, as we showed in the DAD book, for non-trivial enterprise deployments the transition effort can be significant. In fact, the November 2010 Agile State of the Art survey found that the average agile team spent six weeks in their transition efforts, with some respondents indicating spending one day or less and some indicating twelve weeks or more. There are several reasons why this happens:
- Transition isn’t agile yet. Many organizations are adopting agile techniques for construction but not for other aspects of the delivery lifecycle. This is often referred to as “Water-Scrum-Fall”. As a result these organizations are inflicting traditional, labor intensive transition practices on their agile teams.
- We’re dealing with more than just software. It’s often a bit more difficult than simply copying some files onto a production server. Mainstream agile methods describe the goal of creating “shippable software” at the end of every iteration. That’s a wonderful, overly simplistic philosophy that doesn’t hit the mark in practice. In DAD we prefer to use the phrase “consumable solution” indicating that shippable does not necessarily mean usable software. Furthermore, in many situations more needs to be delivered than just software – there may also be hardware upgrades, the business processes surrounding the use of the system may evolve, and even the organization structure of the people using the system may evolve. In short, disciplined agilists adopt a solutions over software mindset.
- Transition occurs infrequently. Some agile project teams adopt a long release cycle, often six months or more, and as a result don’t have sufficient opportunities or motivation to get good at deployment. Sometimes this is due to the nature of the solution they’re working on but more often than not it’s because of the cost of transition – the greater the effort to transition into production the greater the cost to do so, therefore you need to spend more time building the solution to add sufficient value to justify the cost of transition.
- Lack of vision. Many IT organizations don’t believe it’s possible that releasing solutions into production can be evolve from a multi-week phase to a multi-hour, or even multi-minute, activity. Or they realize it’s possible for others to do so but not them (I find it amazing how many people believe they’re in a special situation or blame others, often senior management, for not being able to adopt fundamental strategies that would improve their approach).
Because of the potential complexities of releasing a solution in most mid-to-large sized organizations the deployment of solutions is carefully controlled. This is particularly true when the solutions share architectures and have project interdependencies, one of the reasons why DAD promotes the need for enterprise awareness within agile teams. For many reasons release cycles to your stakeholders are less frequent that you would like because of existing complexities within the environment. However, the ability to frequently deploy value to your stakeholders is a competitive advantage; therefore you should reduce the release cycle as much as possible. To do so requires a great degree of discipline in areas such as:
- Quality practices. First and foremost, testing and any related fixing should be done as much as possible during construction iterations. Transition is not a “stabilization phase” nor is it a “test phase”, it’s a deployment effort. Granted, you should still run your regression test suite(s) one last time as part of your overall deployment effort, with the potential that if tests fail you will need to do some fixing, but this should be a minimal effort. The implication is that quality practices – including testing, refactoring, reviews, code analysis, and so on – be performed continually throughout construction.
- Pre-production integration and deployment testing. These are two of the most challenging types of testing, and sadly they’re often given short-shrift in the agile literature. The goal of pre-production integration testing, sometimes called production testing, is to test the solution in the best approximation of the production environment as possible. This can be particularly challenging in larger organizations where hundreds of systems are already running in production and dozens are being worked on at any given time. To make this testing economical during construction many organizations find that they need to go beyond the “whole team testing” approach with a parallel independent testing team that focuses on complex forms of testing that development teams can struggle with. Similarly deployment testing can also be a challenge because its goal is to determine whether you can successfully deploy into production.
- Regular coordination between project teams and with operations and support staff. Throughout construction you will want to ensure that the development, operations, and support teams are all aligned. One aspect of DAD’s enterprise awareness is to include DevOps strategies, such as treating operations and support staff as key stakeholders that you need to work closely with throughout the lifecycle, in the process itself. The better the coordination the smoother, and therefore quicker, transition will go.
- Adoption of continuous deployment practices. The fundamental idea behind continuous deployment is that the more often you choose to deploy the better at it you will get. This happens because you have more opportunities to hone your deployment skills and also because you’re motivated to find ways to simplify or automate deployment activities.
I’ve seen teams evolve transition phases of several weeks down to several hours through adoption of the disciplined strategies mentioned above. A disciplined agile team may start with relatively long Inception, Construction, and Transition phases and over time shrink all three down. Over time the Inception phase mostly disappears, particularly if you maintain team consistency between releases, and as I’ve argued in this posting the Transition phase shrinks to a very small activity. When deployment becomes inexpensive it enables you to have shorter construction phases and thus more regular releases – teams go from annual releases to bi-annual, then to quarterly releases, then monthly, weekly, and yes, sometimes even daily. Your team will need to choose a release cadence that makes sense for you.
These days it is fairly easy to observe multi-billion dollar companies, particularly e-commerce companies but even staid organizations such as financial institutions, deploy on a monthly, weekly, and even daily basis. If other organizations choose to work this way then why can’t you?