Enterprise development organizations are increasingly embracing agile as a concept, if not entirely in practice. That’s because adopting and scaling agile methodologies for large, complex enterprise software projects can seem daunting. This is particularly the case for groups tasked with developing legacy software, in which the desire to be more agile is often hampered by outmoded mindsets, processes, methodologies, and technologies.
Just how common is this “agile gap?” In a recent Forrester Research survey titled “Forrester Development Landscape: 2013,” 37 percent of developers confessed to using no formal methodology to guide their work. Only 19 percent said they used some form of agile. Clearly, there’s room for improvement.
So, how can enterprise organizations realize their agile goals? I believe there are five key success factors for scaling agile development for enterprise software.
1. Create an Agile Culture
Agile is not just about process—it’s about people. Creating a culture that embraces agile principles is the key to success. But, Rome wasn’t built in a day and neither is an enterprise culture. Start small and build with incremental steps.
Start by securing executive sponsorship so change leaders know that management has their back. However, agile culture is not a top-down change; it’s all about empowering teams. So, while managers should provide leadership and mentoring, this should be in the form of coaching each product owner and ScrumMaster to increase their team’s velocity, quality, and efficiency. Let team leaders make the hard calls, providing advice offline and supporting their decisions.
You should fuel excitement and energy. Create a dedicated “Scrum room” that serves as a focused, “cool” place for each team to interact and feed off each other’s energy. Things like interactive white boards, release and iteration charts, and build dashboards promote teamwork. And, showing recent field defects helps connect developers with the customer.
Create a clear definition of “done.” Also, turn up the volume on velocity by time-boxing releases and setting sprints for one-to-two weeks in order to be more responsive to stakeholders and customers. While not every sprint will be releasable, that should be the goal.
2. Model Agile in Your SCM
Mapping your agile process into your software configuration management (SCM) is crucial to propagating change across multiple configurations in a reliable, efficient, and auditable manner.
To help drive agility, SCM must enable development teams to:
- Manage delivery of change independently while effectively managing dependencies
- Make delivery decisions late in the development cycle
- Adapt releases and projects mid-stream to respond to changing requirements
To achieve these goals, effective organizations seek out SCM solutions that enable them to do the following:
- Use streams to isolate change according to levels of software maturity and levels of functionality. This enables an efficient, parallel pipeline that avoids the integration “log jam” common to traditional branching techniques. Old-school tools can’t provide the isolation and structure needed to drive this level of agile delivery and software change.
- Implement change packages to allow delivery of change independently from other changes. Developers should be able to promote, demote, and “cherry pick” code at user-story levels of granularity. Traditional SCM tools that manage change at the file or transaction level make this extremely difficult and error prone.
- Simplify inheritance to drive continuous integration by propagating changes frequently and in small, manageable batches across parallel development streams. The ability to have changes propagate forward and backward within the development pipeline is critical.
- Maximize automation and traceability to remove error-prone, manual tracking of code to issues. This also enables developers to see progress being made against an iteration or larger epic. The ability to visually model and control the development process is essential to knowing the true state of code.
When you can tick all of these boxes, you have a pipeline optimized for continuous delivery, a pillar of agile development.
3. Use a Hybrid Model for Legacy Development
Developing legacy software demands a special “hybrid agile” model that combines aspects of agile with waterfall approaches. Using a hybrid model, overall project planning may remain “stuck” in the waterfall, but teams can still work on delivery in an agile way. The important thing is to be as agile as possible in your implementation, even if your planning processes are not 100 percent agile.
For example, focus on developing sections of code that have been identified as needing innovation. The model serves as a blueprint for defining the relationships between legacy software and new integration components. Using your SCM solution to define the interfaces between waterfall-developed legacy code and new code enables companies to move forward with agile through small, evolutionary changes.
4. Scale Your Agile Process
One of the great things about agile for enterprise organizations is how well it scales. Simply expand the Scrum concept up to the next level of management, creating a “Scrum of Scrums” (SOS) led by the director or VP of engineering as the product owner. Above this level, create a product steering committee to serve in an advisory role on strategic goals, such as portfolio investments and product roadmaps.
During SOS meetings, each Scrum team discusses its progress, issues and impediments, allowing teams to share and benefit from each other’s experiences. Perhaps the most crucial role of the SOS is to define the minimum definition of "done."
Finally, implement a portfolio dashboard to track the planned release backlog versus the velocity in order to predict which releases are headed to release candidate status.
Managing this scaled SOS structure is a lot easier if it’s supported by an agile-centric project management solution. Ideally, your project management solution should be integrated with your SCM to create a “closed-loop” approach. This unifies everyone involved—from planning and project management to development and delivery—facilitating effective communication, collaboration, and feedback to drive greater accuracy, speed, and quality.
5. Watch Out for Pitfalls
Congratulations. You’ve adopted agile methodologies, created an agile culture, and are scaling it up across your enterprise. Now you need to be vigilant to stay on track and not get sloppy. Watch out for common pitfalls that break agile, including the following:
- Having an unrealistic definition of “done.” Make sure the definition is clear and achievable, not overly complex or over-ambitious.
- Not having testable code. As code moves up the maturity scale, it must undergo frequent testing and quality inspection. Without the right automation, catching defects manually at higher levels is difficult and costly.
- Team spelled with an “I.” Agile is a team-based methodology. In order for it to succeed, all team members must be engaged. Allowing one team member to control the team and not allow everyone to speak will stifle vital collaboration.
- Slowing down. Quick builds and frequent or continuous code integrations are essential to agile. Make sure to keep up the pace. Automate aggressively and limit how often teams can stay isolated.
- Slipping back into old habits. One anti-pattern organizations commonly fall into is reverting back to one main code line because change management is too difficult. Having an agile-centric SCM solution can help avoid this by simplifying and automating change management.
Implementing and scaling agile in large, enterprise development organizations is not only possible, it’s becoming a strategic imperative. As with many cultural shifts, the first step is often the hardest. The most important success factor of all is this: get started now and take it one step at a time. Once your organization begins to see the benefits, building support and energy around agile will only get easier.