This article was originally published on outsystems.com
Peer inside the modern IT organization, and it can be a bit like Dr. Jekyll and Mr. Hyde where the character furiously switches between two opposite personas (but hopefully without the confrontational part).
On one hand, you have excitement about DevOps, continuous delivery, and the entire idea of rapid and iterative development.
But when it comes to legacy environments, it’s as if IT becomes a completely different organization—even when the same people are involved. Gone are the fast-moving, iterative approaches, and DevOps. The traditional project-oriented waterfall methodology returns.
This fallback is particularly evident when it comes to the granddaddy of legacy projects: modernization.
Progressive organizations are realizing that skipping DevOps during modernization efforts is a missed opportunity and are starting to buck the waterfall and legacy trend. But as they do so, they are finding that DevOps and legacy modernization can be a tough fit.
Part of the challenge is cultural and founded in the way that organizations and IT leaders have typically looked at modernization efforts. Jason Bloomberg, president of Intellyx, discussed these factors at length in two previous articles, one of which was Modernization: The Old Way and the New Way.
The architecture of legacy environments and their rigid structural elements are often what push organizations into a waterfall mentality in the first place. Applying Agile and DevOps principles is difficult when the rigidity of an environment makes it onerous to break it into movable pieces.
The good news is that organizations that are trying to apply DevOps to modernization now have access to an enabling tool from an unlikely quarter: low-code development platforms.
Reimagining Modernization in the Context of DevOps
The first step in applying DevOps to modernization efforts is, as Jason explained, to change the way you look at them.
Modernization is no longer limited to the wholesale replacement of an aging application. Organizations have rightly begun to approach it more modularly, exploring how they can modernize parts and pieces of an application as business and architectural needs demand.
Breaking a legacy application into more bite-sized pieces has the effect of reducing risk and increasing manageability, and represents a significant step forward. However, most efforts are project-oriented dissections of the traditional waterfall approach to modernization. This does little to help organizations adopt a true DevOps mindset.
To make this next leap, organizations need to shift toward the deconstruction of modernization efforts at an architectural level. This architectural view involves breaking up legacy modernization efforts not into sequential parts, but into the deconstructed elements of the legacy application stack, such as data, process, logic, and the user interface. Then, you only modernize the parts that provide the immediate value you seek.
This reimagining of a modernization effort frees organizations from the bounds and constraints of the old application and the pre-ordained way of looking at things.
But it’s not all sunshine and roses. Abstracting the architectural elements from functional requirements can turn the management of a modernization effort and the construction of a new stack into a nightmare. You need to be able to move fast enough so that nothing breaks as you do so—and then be able to iteratively transform the newly developed components as other teams transform other parts of the architecture during the broader modernization effort.
If you’re coding by hand, that can be a tough mountain to climb. Deconstructing a complex application into both its functional and architectural components to modernize it is a bit like taking an old television apart piece by piece, laying everything on the floor, and hoping that you can rebuild it into a new LED flatscreen TV.
First off, you can’t just refashion it into something that it’s not—you’ll need to build some new parts to make this work. Second, the prospect of doing all of this by hand is downright scary.
Using Low-Code to Bridge the Gap
Thankfully, low-code development platforms are emerging as a viable way of bridging the gap between old and new and turning the process into something much more manageable.
A new generation of low-code solutions, particularly those enterprise-grade varieties like OutSystems, are specifically aimed at helping make modernization much easier. They give modernization teams the ability to abstract efforts yet move at both the velocity and scale such efforts require.
The declarative, abstracted nature of these low-code platforms enables teams to work at a conceptual layer and break the architectural and functional components apart as they develop new application elements that either replace or run alongside legacy components.
More importantly, however, this same declarative approach enables teams to rapidly iterate and change applications as the project demands. Teams can collaborate and iterate at will. The dynamic nature of these low-code platforms provides the flexibility needed to apply DevOps principles to legacy modernization.
It is more than just the development process, however, that makes low-code an enabler of these iterative approaches to legacy modernization. Many of these platforms, including OutSystems, provide substantial, yet intuitive integration capabilities that enable modernization to occur either in place or in new environments—and often in both—as needs demand.
This ability to dynamically integrate the new and the old and then seamlessly evolve those integrations over time is critical for applying DevOps to modernization efforts.
The Intellyx Take: Ignore Low-Code at Your Peril
To modernize so your organization can take advantage of the new technology, platforms, and approaches that promise to transform the customer experience and drive differentiated business value for your organization, DevOps is essential. Otherwise, the complexities of modernization efforts can rapidly make it seem as if the outcome is not worth the heartache.
As we have been exploring in this series, the first step is to reimagine what it means to modernize and to change the way you look at the process. But that fresh mindset only gets you so far. The rubber meets the road at the point of execution—and execution is where most modernization efforts go sideways.
As enterprise leaders seek a way to strike this balance—to move their modernization efforts forward using modern techniques and approaches—the application of yet another technology domain to close the gap may seem counterintuitive, as any new technology has the potential to increase complexity and risk.
Organizations, however, will ignore the use of low-code in their modernization efforts at their peril. Deconstructing legacy applications into abstracted components and applying a strategic and precision modernization plan focused on business value require that organizations move faster and at a greater scale than hand-coding will, in most cases, permit.
Enterprise leaders are now realizing this fact, and it is leading them to a clear recognition that low-code platforms can help them bridge the gap as they apply DevOps to modernization.
Copyright © Intellyx LLC. OutSystems is an Intellyx client. Intellyx retains full editorial control over the content of this paper.