This is a discussion of the tension and its mitigation between ITIL Release Management and Application development (projects) and enhancements from a particular real world occurrence.


While working for a major global manufacturing company they elected to re-outsource with a new model in the middle of last year. This was managed in a coherent programme fashion, but of course not all the details could be fleshed out and integrated in advance as they are a huge organisation.

There was a fundamental schism in the re-outsourcing between Services (infrastructure and operations) and Systems (application support and projects for applications). Each side of this schism placed contracts both for the front line performing suppliers, but also for a higher level set of integration services.

On the Services side of course there was bed rock written into the agreements to employ ITIL processes. And of course the integrating supplier on the services side arrived with their own vision and tool(s).

On the Systems side these contracts brought a standard approach to a considerable portion of the legacy application sustain (break / fix) and small enhancements. Vendors were organised by sets of applications the performed a band of business process functions.

However the integration was meant to occur with two layers of vendor, and the over arching did not get to a standard or common approach on application enhancements quickly. As a result different organisations defined by bands of functionality executed somewhat differently for application support.

Mechanics for governing changes were vague, but in the space in which I worked discretionary (not the break / fix) enhancements were set up with service level wording that clearly required their management change by change, item by item. Additionally, more because of history, governance was set up to support the dialogue about when each change could be made with the end user or business partner.

The company was far more standard on macro co-ordination of application projects. There were a set of different cases but all of these were derivatives of a recognisable PMBOK (Project Management Book of Knowledge) approach.

For our purposes I will put projects into two groups. First there were waterfall projects (Plan, Define, Design, Construct, Test, and Deploy) and then there were iterative, or cyclic (RUP) kinds of projects.

There were numerous variants, such as splitting off the plan and define from the construct through deploy. Often in these cases one plan define might launch several construct through deploys. And also often the plan and define parts might get shelved and require a refresh before going into the true construct through deploy.

Release Management

Release management at a company wide level was really rather new thinking. It has begun before the re-sourcing had occurred, but was planned for a functionally phased implementation.

The first steps had already occurred without tension. A set of applications had been identified as the target scope. Logically this was things like the more important applications in business terms, and the SoX controlled applications. Schedules for when these applications would allow for changes to be promoted to productions were developed and communicated to a central production control team. The intent of course to be able to manage these between various dependent application changes and together with server and infrastructure changes.

Also in the early and less controversial implementation was the development of policies for these applications regarding release management.

And since a full ITIL vision was being pursued Change Management had been partially implemented. It was in fact the "back end" that was put in place. The gate keeping for promote to production was put in place with Change Authorisation Boards (meetings) supported with a tool. Each change was submitted in the tool, reviewed at the meeting for being acceptable, and tracked into production and acceptance.

The "Rub"

Now the tension showed up when the logical next step was taken, which was the concept of mapping the "what" was going to change to the "when" it could change in the already defined schedule. Trouble began when they wanted release plans with scope well defined.

In all cases the vision called for Release Plans that had a 2 year horizon, of which 12 months was firm, and 90 days committed or "locked". Clearly for application development and support staff striving to be ever more responsive to the end users and business customers this thinking just isn't going to fit. We are talking about an organisation with a stated goal of delivering value (code promotion) every 90 days in the big picture. This is a company that conceives and wants to execute a marketing programme to react to real world pressures in 30 days or less. Bottom line - no way, no how was locking 90 days going to work. Nor was there going to be much more than a 6 month horizon to what could be foreseen.

Another layer of difficulty arises with the more traditional projects being executed. The conceptual framework includes drilling down or elaborating to arrive at discrete requirements. There is seldom a bank of back logged, crisp changes to be pulled into a group to define a release. (Sometimes when a more robust plan and define moved into design before being shelved or put on hold they might exist.)

Throughout the life of the project the "onion was peeled" and requirements became clear. But once clear there wasn't going to be any delay in getting something built and deployed. There was no appetite to put in a schedule out more than 90 days on the horizon.

Iterative projects evidenced a mix of symptoms. To some degree when in the second or later iteration there were crisp changes that had been defined and purposefully held for later iterations. Very similar to release planning required. But the kicker was, the joint application development flavor meant that something new may well arise in working with the users from one iteration that would take precedence of all other things and go into the next. This once the occasional exception. This was meant to be. Constantly resurfacing the more important needs and not emphasising a locked or firm horizon. It wasn't a case of doing out in the next open release, but constant review for including the highest value changes in the next iteration.

With the small enhancements the problem was the management required for them one by one. They were not bundled for coding and testing but executed individually. They were planned for a release schedule date, but the plan and management wasn't for a bundled release, but needed to be item by item. Including the entries in the change and release management tool. In turn, this matched the service level of the contracts more exactly.


So the trick to mitigating these arrangements conceptually around at least the projects is rather easy. Soften up on the targets for locked and firm schedules of scope and allow for the elaboration of information around what is in what release as things are known.

Pretty clear that what duration should be locked and firm should vary by business condition, by application.

What got in the way in this instance was the tool. It was designed with two layers. One a set of well defined detailed change records and a collector release record. As a result the only way to elaborate change in terms of how much was known to revise the descriptions as things were understood.

In a large and complex environment where the project management and tracking tool doesn't interface with the change and release management tool this becomes considerable duplicate effort. And worse, it is a structure and mode that isn't natural to project teams.

So, not only would I advise that the tools be integrated, but that the release management tool might be constructed with multiple layers. The top set of records could be just defining the dates or windows of opportunity for promote to production. A next layer could provide some definition of scope, but less detailed. This would equate to a "firming" and have a horizon appropriate by application. One would define what the firm horizon should be in the policy for the application.

Then of course the final set would equate to committed. These would be well defined changes. However, allowance should be made to allow recording these and moving them when known. Rather than a fixed horizon targets for how many of the changes were recorded at this level how far out would make more sense. For instance:

  • 95% should be known 30 days out
  • 80% known 60 days out
  • 60% known 90 days out

The small enhancements were in fact mapped to target release schedule dates for promotion to production. Again it was the tool that got in the way. It was the concept that they would be bundled and managed through code and unit test as a set.

The solution would be to manage them from approval to execute through code and unit test individually. They would "committed" records as above once approved. What would be different is that status and tracking would be preserved at this lower level, not at the release level, until the release or bundle was ready for integrated testing and promotion to production.

A Better Solution

So what I carefully avoided above was the fact that there were sustain or application managers for the small enhancements handling changes. At the same time there were project managers handling major development efforts for sets of functionality to the same apps.

On the project side you had rotating project managers and teams for the same application. Often loosing continuity of oversight for an application over time.

To really make this work better, you need to make organisational change and shift from assigned by project teams in conjunction with sustain teams to product teams with release managers that comprehend both the small enhancements and the project work equivalent executed as releases. Unfortunately that is far from trivial.

The Author

John R Ashman PMP