Steps to Successful Mainframe Modernization

It is customary to think about mainframe modernization as a multi-year transformative effort that entails lengthy planning stages as well as a substantial buildout before any tangible benefits can be achieved. For sure, short-term migration options such as offloading work to lower-cost processors, obtaining volume discounts from your mainframe provider, utilizing hardware and middleware emulators, leveraging COBOL-to-Java code generators, deploying REST APIs on top of mainframe systems, and outsourcing code refactoring and redefinition are all appealing. However, although these initiatives are well-intentioned, they rapidly get bogged down in the mud because they do not scale and, as a result, are unsustainable in the long run.

Modern software development methods, such as the XP methodology and Flexcube implementation, stress the need to begin simple and have rapid feedback loops, allowing developers to produce early and frequently. Consequently, how can businesses balance their need for rapid expansion with the idea that mainframe modernization would take extensive planning and execution? At JMR Infotech, we employ a six-step iterative approach to mainframe modernization that offers the organization incremental improvements and a return on investment.

Migration from the mainframe monolith to cloud-first microservices

The fact is that mainframe upgrading is a complex undertaking. Furthermore, the process becomes worse before it becomes better since concurrent development workstreams must be maintained simultaneously for legacy and net new development projects. After assisting a number of clients on their mainframe modernization journeys, we have developed an iterative, staged approach to mainframe modernization that not only scales but also generates ROI in days and weeks rather than months and years, as previously thought.

Rather than rewriting the COBOL code line by line, the purpose is to convert it to a distributed platform. This is a futile endeavor that will fail in the end. Instead, we want to retire code and any functionality that is no longer required to meet the present and future demands of the company, and we want to do it quickly. Our strategy consists of six stages, which are as follows:

1. Start with the end in mind

Is there a specific business event or condition that has prompted the modernization effort? We must understand why the modernization program is being financed in order to develop the most appropriate set of goals, objectives, and critical outcomes for the program. As a result, we ask our customers: Are you doing this because you cannot add functionality quickly enough? For the simple reason that you want to present your end customer with a whole new, digital, 360-degree experience? To put it another way, what are the most critical business drivers?

The business and technology executives must be the driving force behind this alignment, which must be supported by all product owners, product managers, and technology leaders. It is expected that the conclusion of this phase will be a clearly stated set of goals and objectives and measurable key outcomes that will serve as journey markers to verify that the mainframe modernization initiative is on schedule.

2. Discover candidate services

Once this has been accomplished, it is necessary to take stock of the essential systems operating on the mainframe in terms of the business processes they support to break them down into distinct, independent capabilities that can be described as microservices. Event storming is the term used to describe this process. As a result, it can be used to understand the system’s top constraints, conflicts, and inefficiencies and to reveal the system’s underlying bounded contexts while also allowing for the modeling of new flows and ideas, synthesizing knowledge, and facilitating active group participation in order to come up with ideas for the next generation of software systems. We utilize the seams of the present system to inform the design of the new distributed system. Still, we also include features of XP, such as user-centered design and design thinking to guarantee that our knowledge of the system reflects reality. When this phase is completed, a set of service candidates — also known as “bounded contexts” in domain-driven design language — will reflect the business capabilities as a collection of core, supporting, and generic business domains.

3. Map thin slices

A crucial mainframe system — such as commercial loan processing or pharmacy administration, for example — has many end-to-end procedures that must be followed. For modernization, we employ event storming to understand the critical business processes since they offer the steel threads that hold everything together. In addition, we must prioritize these critical processes since they will serve as the foundation for system design and implementation. First and foremost, the happy route flow must be selected as the narrow slice that delivers value from beginning to finish while demonstrating incremental progress. This will eventually increase everyone’s confidence in the whole process. When this phase is complete, a collection of prioritized thin slices contain the event storm and provide business value.

4. Design notional target architecture

Following the identification of all of the necessary components, the next step is to integrate them all together to develop the new system, which will include messaging, data, APIs, and user interfaces. Flexcube is used for wiring up all of our domain services since it offers a disciplined approach to defining synchronous API connections and asynchronous event-driven service interactions. We look for links between services to expose the hypothetical goal system architecture and document these linkages. In order for the thin slices to work across contexts, we describe the APIs, events, data models, and views that would be applicable to the context in which they would be used. The conclusion of this phase is a notional goal architecture for the new system, with external contact modes sketched out in terms of messaging and application programming interfaces.

5. Create a user story backlog representing tactical patterns to strangle the monolith

In some senses, upgrading the mainframe is like lowering a jet down from 30,000 feet to the earth. Currently, we are in the latter stages of our drop and hanging approximately 10,000 feet above the ground. Understanding how these old and new systems will co-develop without causing a rift is critical to the success of this project (i.e., how to change the engine while the plane is descending). We leverage a series of modernized tactical patterns, such as the anti-corruption layer, façade, and data-driven strangler, to create a set of MVPs and align user stories. The Oracle Flexcube system we created earlier will be realized via the user stories, and the tiny slices we modeled will be put into practice. User stories are designed for modernization in this phase, which integrates tactical techniques for living alongside the monolith.

6. Craft a roadmap of epics and build

Having a backlog of user stories, we’re presently less than 1,000 feet from the ground in terms of aircraft height. It’s critical at this phase to identify and handle the main technical implementation issues, such as latency, performance, security, and tenancy. To do this, we develop a user narrative journey map that will bring the system we designed earlier to life and implement the thin slices we modeled. ” As we begin to build up contracts for our APIs, we need a roadmap of MVPs to ensure that other teams and dependencies aren’t hampered. It is only after deciding on an epic structure that we can begin to assign product managers and engineers to work on a project, therefore opening the feedback loop from product development to the business. At the genesis ceremony, a road map of MVPs based on epics and individual user stories is created. Setting a cadence for demonstrations, iteration planning meetings, and retrospectives is essential since it will set the tone for the remainder of the project in terms of feedback loops for gradual modernization. The initial iteration of development results from this phase of the project.


It’s not uncommon for us to do the six processes of mainframe modernization more than once, depending on how many distinct sections of a complicated domain they apply to. Some stages may even be skipped entirely if we are already familiar with the Flexcube domain. This six-step procedure is not prescriptive in any way. What works for you is what you should do, with speed and a goal architectural map in hand, to update the system incrementally.