Pivoting at Speed to Scaled Agile and DevOps – Chapter 2
Chapter 2 – Turning on a Dime
Being able to respond quickly to a changing environment is what businesses aspire to but also something that is ingrained in our humanity. Having a large program that needs to adjust course in order to avoid disaster is easier said than done. Last time we fixed the radar and realized that without changing course, we were likely headed for just that disaster.
Of course, knowing you need to do something and actually doing it, however, are two very different things. For this, we used an agile approach and moved forward one step at a time. In our case, we developed a “get healthy” plan to make the necessary changes. We broke the plan down into 30, 60, 90 day incremental changes to show improvements over time, validate and then adjust as needed.
Its all about the Basics
Why a “get healthy” plan? If we think of an ailing program like a person who’s not feeling well and you don’t know exactly why, there are certain actions we can take to improve that person’s condition. From doing analysis to providing medicine and more treatments. But if we try to do everything at once, we could make things worse. Instead, we iterate through a series of changes to see if what we’re doing makes things better.
In our case, the the core program management team and stakeholders met in a weekly scrum to plan changes and evaluate the changes made against our “get healthy” plan. Some of the things we worked through were:
- Reporting and tracking of progress
- Risk and Issue Management
- Program communications
- Decision making on changing requirements
- Change Management
- Restructuring the work
Most of you will recognize that this is starting to sound like your typical program management checklist. It is. But too many changes at once results in failure. Incremental change and adaptation allows you to make the right changes when they matter the most while you continue forward progress.
To Scrum or not to Scrum?
That is the question. We had five different system development teams each with their own lifecycle and development approach and thinking they were accomplishing work, but then scrambling at integration testing time to respond to what the other development teams had built.
But as the integration testing progressed, and more and more bugs were fixed that were seemingly caused by less than ideal communication earlier in the development, we observed the natural formation of cross-functional teams. That is, individuals on each development team now working closely together on a daily basis to ensure that the various components they had developed independently would now work together. This was great. This is the type of behavior we want to see. The problem? It was a bit too late. Too close to the integration test cycle where users would see the system. This resulted in confusion and overworked people and implementation challenges. But what if we could harness the positives of this approach and eliminate the pitfalls…
Enter: Integrated Delivery Teams (IDTs). IDTs consist of contributors of multiple system development teams that would come together as a single scrum team to deliver features. The features span multiple systems and this is a key way to eliminate hand offs between teams. The IDTs are autonomous in that they have all of the expertise from business to every application involved in the functionality to deliver. Is this a Scrum team? Yes, for all intents, however, the difference being that members of the IDTs work on different applications on different platforms to deliver integrated capability.
The challenge here is, of course, the very fact that we’ve taken individuals from multiple system development teams and combined them into one team at the same time that we’ve split the system development teams apart. In addition, we’ve given authority and accountability to a business lead who can call the real-time shots on the business functionality that needs to be developed. This is a bit of a culture shock, but it works. Is this a Scrum team? Absolutely. Does everyone on the team work on the same application? Absolutely not.
What we get from this approach is the elimination of handoffs between the different application teams. Now we have a single integrated team responsible for the end to end business capability. What this also enables is predictable delivery of the capability that the business stakeholders can see during a demo.
The Right Focus
Once we have the IDTs defined, we need to ensure that they have the right work to execute. The importance of understanding which areas specific business capabilities impact and how to distribute these to the teams cannot be understated. This is where the role of a Solutions Architect along with the business leads help. The cross-system changes dictated by the business capabilities need to be viewed across the entire solution and not within the scope of a single system or IDT.
This visibility, perhaps, is the most difficult part of moving to scaled agile. And, where the scrum of scrums comes into play along with ensuring that the IDTs have the autonomy to do what they need with the authority of the business lead on the IDT. But once you’ve got a grip on the high-level business capabilities and how these capabilities impact the systems, the IDTs can move into their sprint grooming and planning.
Now we’re changing our course to (hopefully) a better path. A path that will get us to success. But, as many complex initiatives, the devil is in the details. How do the IDTs operate on a daily basis and how to we ensure crucial dependencies are understood well in advance? In our next chapter, we’ll take a tour of the engine room where all of these and more happen.
Join Red Hat Developers, a developer program for you to learn, share, and code faster – and get access to Red Hat software for your development. The developer program and software are both free!