Once a company realizes the potential benefits of modernizing mainframe applications to the cloud, and moves beyond the fear of modernization, there are several modernization strategies to consider. And while the modernization strategies may not be all that new, they bear repeating in the context of modernizing mainframe applications by transforming them into cloud applications. Let’s discuss four proven strategies:
Several technologies exist for recompiling and executing mainframe applications onto commodity servers in the cloud. Vendors offer emulation platforms to run COBOL, VSAM, ISAM, CICS 3270 green screen, among others as-is within a Linux environment. Once “shifted” to a commodity server platform, the application can be placed into virtualized workloads, such as Linux running on vSphere, and managed from within a cloud, such as vCloud. This approach may be the least risky and lowest cost option. Its primary advantage is that it significantly reduces costs by moving from an expensive, proprietary mainframe environment to a commodity-based processing environment. However, it brings little value to the modernized application itself as you are still operating within a mainframe context, maintaining brittle application code and relying on mainframe skill sets and experience. This may be the best modernization strategy if your primary goal is to reduce capital expenditures and short-term TCO.
2. Greenfield Approach
A complete mainframe application rewrite is probably the most expensive and risky modernization approach. However, automated code analysis, code conversion, testing, and cloud deployment tools can greatly reduce the risks and costs associated with this “Greenfield” approach. Taking a Greenfield approach potentially allows you to create the most advanced, cloud-based application available; but this must be weighed against the costs and risks of such an approach.
A candidate mainframe application for the Greenfield approach will be one that continues to provide significant value to the business but is extremely outdated in terms of modern features and functions. In addition to being valuable, but antiquated, a relatively small codebase will lower the risk and costs of a rewrite effort. For instance, a client decided to rewrite their mainframe Time and Attendance system into a web and cloud-based system. The previous mainframe application was only usable by specialists with access to client-side terminal emulation software, and knowledge of cryptic function keys and codes. As a result, employees had to submit paper timecards and leave requests, which were then entered by mainframe application specialists. The new system was accessible to all employees, using a web-browser or smartphone, and was intuitive and easy to use with drop-down selections, templates and wizards to assist with time and leave entries. The new relational data store allowed for better reporting and analytics, permitting them to detect fraud and abuse with greater speed and accuracy.
3. Incremental Replacement
An incremental replacement approach modernizes a mainframe application one module, function, or procedure at a time. This approach has proven to be both cost-effective and less risky than other modernization approaches. This approach is sometimes called the “Strangler Application” because, much like a Strangler vine eventually overtakes its host tree, the modernized cloud application eventually overtakes the legacy mainframe application.
Using an incremental replacement strategy, you first identify the legacy modules or functions that are primarily contained within single data domain and business process or stakeholder group. For example, in a large and complex HR system, you might first target a telework module for modernization: it’s relatively contained to telework data with minimal interfacing necessary to personnel data. In addition, a telework module is a great candidate function for mobile access: allowing users to request telework on a smartphone or tablet from home offers great convenience. Also, the telework module might require elastic scalability during an annual enrollment/re-enrollment period. End users gain immediate and tangible value from your modernization effort.
The process of modernizing a mainframe application module requires converting the legacy mainframe code (e.g. COBOL) to a modern cloud application language (e.g. Java, C#, Perl, Ruby, Node, etc.) using manual and/or automated methods. Technologies including middleware, user-exit routines, and API libraries allow the cloud application modules to be integrated with the remaining mainframe legacy application. Ideally, you develop an abstraction layer (APIs or an interface) between the legacy application and the modernized cloud based application module. The abstraction-layer presents more work upfront but pays off in the long run through risk mitigation—you can operate the legacy mainframe functionality side-by-side with the modernized cloud application module. Once fully tested and confirmed, the mainframe functionality can be decommissioned and the cloud-based functionality takes over. Read More