Great! :)
Thanks, we'll contact you soon.
Legacy Application Modernization: Rebuilding a Legacy Application in Java
How we re-engineered the production workflow app of a major manufacturing company
Company Summary
Our client, a global manufacturing company with outlets in Europe, Asia, and South America, relied on a legacy system to track every step of their manufacturing process. The application managed material movement, product assembly, boxing, palletizing, and shipping.
However, the system was outdated, built using Java 1.6, and lacked modern technology standards. The client needed legacy system migration and legacy application modernization to bring the app up to date.
The architecture was no longer sustainable since it lacked modern standards for technology and best practices.
Furthermore, the client needed the application to be rebuilt to operate efficiently both as a Java web application and for the handheld devices that scan barcodes found on the materials and containers involved in the manufacturing process.
Services: Web development
Technologies: Angular 7, Java 11, Spring (Boot, Security, Data), Microsoft SQL Server, Kafka, Postgres (PostgreSQL)
Project Locations: Egypt, France, Italy
Industry: Manufacturing
The Challenge: Modernize Legacy Applications
Since we were upgrading a legacy Java application responsible for the entire production lifecycle of a global manufacturing company, this project was a significant undertaking. This app tracked everything from raw materials to final shipping, and it was the primary workflow app. Comprised of over 200 wizards that individually contained multiple steps, our team was faced with a number of business and technical challenges throughout the project.
Lack of Consistent Standards
The previous version, built with JavaServer Faces (JSF) using NetBeans IDE, was developed without consistent standards. The absence of RESTful standards, combined with poorly documented business logic and binary files, created a "black box" effect, making Legacy Code Refactoring a time-consuming process.
Database Upgrade & Migration
To modernize legacy applications, we had to re-engineer the data model. This meant upgrading the database without disrupting the workflow. Our goal was to provide a technology upgrade while preserving a familiar user experience, minimizing the need for additional training. The new system also required Java migration to introduce modern functionalities like Java8 features, enhancing efficiency and scalability.
Scattered Development Team
Coordinating across three geographical locations—Italy, France, and the United States—presented its own scheduling challenges.
The client’s back-end developers were split between Italy and France, while our team worked on the legacy system migration from different parts of the world. Despite this, we maintained effective communication using Agile methodologies to keep the project on track.
Our Solution
Our approach to legacy application modernization focused on upgrading the app’s technology stack, database, and architecture while preserving its core functionalities. Through legacy code refactoring and adopting modern practices, we achieved several breakthroughs in performance, security, and user experience.
Updated Data Model
Since the original data model was inefficient, we needed to update the app to a new performance-based data model. However, remapping the database cannot happen all at once. A lack of documentation, and several “black holes” in the legacy app, required the developers to use trial and error to understand the application. Also, we took an iterative approach to upgrading the database since moving too quickly can create serious disruptions for users.
The database currently uses Microsoft SQL Server, but we plan to migrate the system over to PostgreSQL, which is open-source and free. We’ll continue updating the system iteratively, feature by feature, until we have a new version with all of the features detached from the legacy app.
RESTful Standards
One of the main reasons we needed to upgrade the app was to implement RESTful standards to enhance the app’s reliability, performance, and scalability.
With RESTful standards in place, the system is stateless and separates the client and server as components that can be managed, updated, and reused without affecting the system as a whole. This led to a number of performance enhancements and efficiencies in the following areas:
Faster Communication
The original application leveraged a Java-based web framework called JSF (JavaServer Faces) that used the NetBeans IDE. With this architecture, each API was coupled with the user flow and required too many dependencies, and this increased latency and reduced application efficiency.
Under the RESTful framework, API requests are stateless, so data can be cached and retrieved as standalone requests. The new app’s modern architecture has led to better performance, as well as the ability to leverage more advanced functionalities included in recent versions of Java.
Information Sharing
An information gap emerged during the process of upgrading the application. Our team learned that certain terminologies were used by the original third-party vendor, which were discovered to no longer be relevant in the upgrade. By working through these issues and definitions, our team developed a shared language around the features and functions they were addressing.
Performance Targets
In the early stages of our legacy app upgrade, the team often found itself trying to perfect certain features. In the absence of performance targets, this caused the team to take more time than necessary to complete tasks. Thus, our team established targets to set limits on performance enhancement to avoid wasting development cycles.
Better Sustainability
Overall, the app’s modern architecture has increased the application’s productivity and made it easier to fix issues. By working with standard frameworks and design practices, we’ve created an environment with increased sustainability and efficiency.
Effective Communication and Agile
With a scattered development team, it can be challenging to align as well as ensure there are no missing links and the project can run smoothly without running into roadblocks due to things like dependencies. Utilizing Agile, our team was able to stay flexible throughout the project and tackle different aspects as needed. Daily standups guaranteed the team was moving in the right direction together and avoided mishaps like the same engineer working on the same user story.
Outcome
Our legacy application modernization project kicked off in 2019 and is set to be completed in the next phase. Despite the challenges posed by the outdated system and geographically scattered team, we have made substantial progress, including:
- Establishing best practices for legacy system migration
- Upgrading workflows to modern Java8 features
- Transitioning to a RESTful architecture for better performance
- Upgrading the database to PostgreSQL
- Coordinating effectively across Italy, France, and the U.S.
Currently, we have rebuilt about 15% of the 200 multi-step wizards and are on track to complete the modernization process on schedule. This project represents a significant step forward for our client, offering improved efficiency, scalability, and a modern user experience.
As we move into the second half of this project, we look forward to building on our successes and continuing to increase the everyday efficiency and productivity of our wonderful partner.
Sign-up below for updates to this project or contact us to find out how we can help you with your Java legacy app rebuild!
