Modernization 2.0: legacy to microservices transformation

Migrating to a cloud-native architecture is one of the most powerful ways to improve business agility. The modern cloud delivers virtually unlimited, on-demand compute power, enabling platforms to scale instantly to meet demand. It’s no surprise that 94% of companies worldwide already use cloud computing in some capacity, and 97% of IT leaders plan to expand their cloud systems in the next few years (source).

Yet many enterprises remain constrained by legacy, monolithic applications. These systems hold critical business logic but act as bottlenecks to digital transformation. Insurance applications, banking platforms, and other unique software systems have been built over the course of decades in languages like PowerBuilder, EGL, and Smalltalk, among others. These types of systems require a flexible, customizable, scalable, and agile modernization process that can be easily jump-started to deliver incremental results.

But how can you untangle a complex monolith without disrupting stable functionality and critical business operations? After all, carving out pieces of a monolithic system is a manual, labor-intensive, and time-consuming process. To move forward in today’s climate, organizations need a controlled, automated approach that ensures critical functions can be safely modernized, tested, and deployed in a timely manner.

Architectural breakthrough: microservices + micro-frontends

The optimal solution lies in a more modern architecture built on microservices and micro-frontends. Microservices are a web of independent, modular components that can be scaled, updated, and reused individually. Micro-frontends are user-facing components that can operate either independently or as a cohesive whole.

Modernizing the front end is just as important as modernizing straight business logic. Forrester Research finds that companies investing in UI/UX design see a $100 return for every $1 spent. Outdated interfaces remain one of the most immediate barriers for legacy applications, and micro-frontends directly address this need.

Synchrony Systems’ Modernization Lifecycle Platform (MLP) comes equipped with end-to-end automation for extracting “subsets” of business logic and user interface, and transforming them into reusable components for microservices and micro-frontends. This enables organizations to modernize their monolithic legacy applications into a hyperscale cloud architecture. By focusing on the high-value business functionality first, Synchrony helps accelerate modernization timelines so enterprises can deploy and test migrated functions and complete features continuously in months instead of years.

The illustration below shows how MLP orchestrates a modernization solution from a PowerBuilder monolithic architecture to a target microarchitecture with a TypedScript/React frontend and a TypedScript/Node.js backend as the target programming languages. (click image to enlarge)

How monoliths become microservices and micro-frontends

Rather than migrating monolithic legacy codebases wholesale or “as-is,” Synchrony offers a technology-assisted reengineering process and workflow that is iterative, incremental, and analysis-driven.

Analytics and application rationalization

First, an exhaustive analytical inspection of your legacy application is performed using modernization technology purpose-built to identify and extract high-value business scenarios and their execution paths. This analysis produces targeted, self-contained components (a.k.a. “subsets”) for every identified business scenario embedded inside each monolithic codebase. This extraction acts as the foundation for exposing the hidden application “component vocabulary” in terms of application layers, subsystems, and business functions. Powered by the newly exposed knowledge of your system, the extracted component architecture becomes the stepping stone that drives continuous and incremental modernization toward the target cloud component architecture.

Target architecture metadata harness

The new application component architecture is the first representation and visualization of the formerly monolithic application’s structural decomposition into a granular micro-frontend/microservice layer. The component model is used for generating the required metadata that drives the execution of every modernization service agent, such as: a) data access generation; b) business objects generation; and c) UI facelift generation into a reactive frontend. This is where client-specific requirements are also incorporated to align with IT’s model target architecture.

Fine-tuning the transformation engine

The breakdown of subsets further undergoes an iterative process that identifies micro-frontends, microservices, and common layers used by both. An interactive process identifies UI/UX requirements and service layer requirements (typically slated for data access) to produce highly granular, reusable, and scalable components on the target. The process results in custom-tailored code refactoring, transformation, and generation, rules knowledgebases (KBs) for target business services, and facelift rules for a modern, reactive target web frontend.

Orchestrating modernization workflows

The analytics, metadata harness, and fine-tuned transformation knowledgebase are all assembled into custom-tailored workflows. When executed end-to-end, they produce the desired target architecture, consisting of hundreds and often thousands of structural (repositories) and microarchitectural (microservices and micro-frontends) components. Workflows can be invoked on demand by users or triggered by specific events, such as commits to newly generated code or updates to the metadata harness or KB. The holistic integration of code, tools, and processes ensures that the modernization project runs efficiently and at scale.

Continuous modernization

All units of execution inside a workflow, known as “autoflows,” can be thought of as pipelines of pipelines that enable continuous execution of the entire modernization lifecycle. The original monolithic application architecture is incrementally decomposed into independent, atomic, and stateless microservices and self-contained, reusable micro-frontends, ready for deployment into IT-specific cloud environments. The result is a transformed application with cloud-native architecture and modern UI/UX, preserving the original business logic and retaining 100% functional equivalence.

The illustration below shows an end-to-end customized MLP modernization workflow for monolithic client/server desktop applications. (click image to enlarge)

Why modernizing to microservices and micro-frontends improves speed and agility

Customers can continuously extract high-value functionality and features from their legacy applications at their own pace and timeframe, until everything is modernized.
Eliminating dead code and breaking the monolithic functionality into a web of independent microarchitecture components eliminates technical debt and fosters technological agility.
Legacy applications get fully transformed into modern target architectures, unlike the like-for-like, “as-is” transformations that preserve the legacy architectural semantics, making it hard to be agile and scalable on modern target platforms.
Microservices and micro-frontends are delivered incrementally as early milestones for customers to test and deploy into production piecemeal, rather than waiting for the entire application to be modernized.
Built for flexibility and adaptation, Synchrony’s modernization platform conforms to the customer’s specific target architecture, tooling, and requirements (e.g., RESTful, Kubernetes, cloud infrastructure, API gateway, widget libraries, data access harnesses, etc.) rather than dictating a standardized solution.

Real-world transformation: from monoliths to microarchitectures

Modernizing monolithic application architectures into microarchitectures enables companies to untangle decades of core domain functionality and extract it into highly reusable components. Synchrony has helped dozens of teams extract and transform critical domain functionality and UI from their legacy client/server or host/mainframe monolithic architectures into reusable target microarchitectures.

PowerBuilder

A PowerBuilder client/server application subset (after removing dead code and selecting the initial set of high-value components) with a traditional monolithic architecture:

Windows → 323
Data Windows → 1,908
Lines of Code (LOC) → 416K

Yields the following cloud microarchitecture:

Micro-frontends → 47
Microservices → 488
Repositories → 1,650

Would you like to learn how this could be applied to your in-house legacy applications?

Contact us to meet with our senior modernization specialists for an in-depth conversation and consultation about the target architecture options your in-house portfolio of legacy applications can take.

Microarchitecture in legacy application modernization FAQ

This FAQ addresses common questions about our technology, drawing from our expertise in modernization. Whether you’re a developer, architect, or CTO, these insights can help you understand how to revitalize your tech stack without disrupting operations.

What is microservices extraction in legacy application modernization?

Synchrony Systems’ Microservices Extraction technology is an automated tool that untangles complex legacy monoliths and converts them into a network of reusable microservices and microfrontends. It focuses on extracting subsets of business logic and user interfaces from languages such as PowerBuilder, EGL, and Smalltalk. This process creates independent, modular components that can be scaled, updated, and deployed individually in a cloud-native environment, such as TypeScript/React for frontends and TypeScript/Node.js for backends.

Why should enterprises modernize legacy applications into microarchitectures?

Legacy applications are, by definition, outdated. They are built on aging infrastructure and rely on a talent pool nearing retirement to keep running. These systems inherently limit scalability, agility, and innovation. By modernizing to microservices and micro-frontends, organizations can leverage the cloud’s on-demand compute power, enabling instant scaling to meet demand. This shift eliminates technical debt, fosters technological agility, and allows for incremental improvements without a full overhaul.

How does Synchrony Systems’ platform differ from traditional modernization approaches?

Traditional methods often involve manual, labor-intensive processes or “as-is” migrations that preserve outdated semantics, making it hard to achieve true agility. Synchrony’s platform uses end-to-end automation for an iterative, incremental, analysis-driven reengineering process. It avoids wholesale migrations by focusing on high-value business scenarios first, delivering functional equivalents in months rather than years. The result is a hyperscale cloud architecture tailored to your specific requirements, including RESTful services, Kubernetes, and custom API gateways.

What are microservices and micro-frontends, and why are they important?

Microservices are independent, modular backend components that handle specific business functions, allowing them to be scaled, updated, or reused without affecting the entire system. Microfrontends are user-facing UI components that can operate standalone or integrate seamlessly. Together, they create a flexible “web” of components that improve speed, reusability, and overall application performance.

What is Synchrony’s step-by-step process for microservices extraction?

The process is built into the Modernization Lifecycle Platform (MLP) and includes several key phases:

Analytics and application rationalization: An exhaustive analysis identifies high-value business scenarios and extracts self-contained components, revealing the application’s hidden “component vocabulary” across layers, subsystems, and functions.
Target architecture metadata harness: This generates metadata to drive modernization agents, incorporating client-specific requirements for data access, business objects, and reactive UI generation.
Fine-tuning the transformation engine: Subsets are broken down into granular micro-frontends and microservices. An interactive process refines UI/UX and service layer needs, creating custom refactoring rules and knowledgebases.
Orchestrating modernization workflows: Analytics, metadata, and transformation rules are assembled into custom workflows that produce structural repositories and microarchitectural components. These can be triggered on demand or by events like code commits.
Continuous modernization: Workflows run as “autoflows” (pipelines of pipelines), incrementally decomposing the monolith into atomic, stateless components ready for cloud deployment. The final output is a fully transformed application that preserves business logic and is 100% functionally equivalent.

If the modernization process is automated, how does it ensure safety?

Synchrony’s MLP emphasizes controlled automation to avoid disrupting stable functionality. It uses purpose-built technology for inspection, extraction, and transformation, ensuring critical functions are modernized, tested, and deployed safely and accurately. Automation handles the heavy lifting, but the process includes iterative fine-tuning and interactive elements to incorporate your team’s input throughout the modernization process, minimizing risks and maintaining operational continuity.

Can modernization be done incrementally without a big-bang approach?

Absolutely. MLP enables continuous extraction of high-value functionality at your own pace. Microservices and microfrontends are delivered as early milestones, enabling testing and piecemeal production deployment. This eliminates the need to wait for the entire application to be modernized, reducing downtime and accelerating timelines from years to months.

What benefits does this technology provide in terms of speed and agility?

Reduced technical debt: Breaks down monoliths into independent components, eliminating dead code and enabling easier updates.
Improved scalability and flexibility: Components conform to your target architecture (e.g., cloud infrastructure, widget libraries), fostering reuse across teams.
Faster time-to-market: Incremental deployments mean quicker value realization from high-priority features.
Improved UI/UX: Transforms outdated interfaces into modern, reactive frontends, enhancing user experience and ROI.
Full transformation: Unlike “as-is” methods, it delivers a truly cloud-native architecture for long-term agility.

Which legacy languages and systems does Synchrony support?

MLP is designed for a variety of legacy systems, including client/server desktop applications written in languages such as PowerBuilder, EGL, Smalltalk, VisualGen, COBOL, and more. It’s flexible and customizable, able to handle unique monolithic architectures across insurance, banking, and other industries.

How can I get started with Synchrony Systems’ Microservices Extraction technology?

10 app modernization mistakes to avoid

Modernization promises the benefits of a modern, cloud-based tech stack, including remaining competitive, innovating quickly, supporting mobile, and reducing security risks. Yet app modernization initiatives are fraught with complexity. Sadly, over 75% of modernization projects fail, according to multiple studies conducted on mainframe and application modernizations.

Executives, architects, and technical teams must be aware of the warning signs that a modernization project is starting to go sideways. Here are ten app modernization mistakes to avoid to increase your chances of a successful initiative.

1. Shortcutting modernization readiness homework

The devil is in the details regarding app modernization. While limited documentation, technology expertise, or even historical context for changes in the legacy application are common problems, the more significant risk with application modernizations is the inability to scope the project properly. Making assumptions rather than conducting an actual modernization readiness assessment often leads to underestimating the size and complexity of the technical debt and, hence, the overall effort required for the modernization. As a result, the project is set up for failure before it even begins.

2. Treating application modernization like a typical software development project

Nothing could be further from the truth. These applications typically run critical parts of the business, and modernization efforts must be managed in parallel to support the day-to-day business operations. Unlike the typical greenfield development lifecycle, where many engineers make many small incremental changes to one program or function at a time, a modernization project makes wholesale changes to millions of lines of code simultaneously and repeatedly. Planning a modernization project like a greenfield project is a huge mistake.

3. Assuming a good migration tool is the only key to a successful modernization

Machine-driven migration tools are crucial to modernization projects, but they are just a part of a successful modernization project. These tools are akin to best-of-breed compilers and their role in greenfield application development. Yes, we need a good compiler, but without the well-established best practices of DevOps, no compiler by itself can ensure the successful completion of a software development project. So yes, we need good migration tools. Still, they must be integrated into holistic modernization processes that help bring migrated code to production quality, see it through to production release, and retire the legacy application.

4. Overreliance on code migration tools

Piggybacking on the above, teams always investigate the available code migration tools. Automated code transformation takes care of only a third of the work in a complex modernization project with many moving parts and stakeholders. Without integration of migration tools with CI/CD build pipelines, defect management, test management, code synchronization between parallel development and migration tracks, project management, analytics, reporting, and more, it will be impossible to successfully manage such complex projects and see them through to completion.

5. Underestimating the difficulty of modernizing a moving target

Applications that require modernization are often live/running systems that undergo development – bug fixes, enhancements, feature requests, integrations, etc. – based on the needs of the business. Halting development or freezing the application code isn’t feasible, especially when today’s modernization projects average sixteen to twenty-four months or more. The biggest Achilles heel of modernization is the inability to keep up with the rate of change happening to the application while it’s undergoing modernization.

6. Trying to modernize everything at the same time

The end-state is clear. A modernized application will use modern technology, be cloud- and mobile-ready, and embrace current UI/UX best practices. However, the system to be modernized is typically monolithic and was developed with what today would be considered obsolete software development practices. Trying to tackle this challenge all at once significantly increases the risk of failure as it drives up the demand on resources, time, and costs and ultimately erodes the trust of senior executives and project sponsors. Instead, develop a minimal viable product, or MVP, modernization roadmap. An incremental approach will still result in wholesale modernization, but it’s being done piecemeal. This incremental approach makes modernization more manageable, trackable, and measurable and de-risks the entire project.

7. Not having project visibility

Large-scale, complex application modernizations often require internal resources and several external partners with specific migration expertise. The work is usually managed via spreadsheets, Gantt charts, project management or collaboration tools, and constant status calls. Outside the project management activity, the modernization work occurs in various development environments siloed to the teams working in their particular areas. So, despite everyone’s best intentions, modernizations are fraught with miscommunication, delays, and project bloat, costing more money and time. These challenges must be acknowledged and addressed as part of the overall modernization strategy and, where possible, solved with modernization lifecycle management solutions.

8. Tracking the wrong modernization success metrics

Some metrics show project progress but may not be success indicators. For example, measuring the number of migrated lines of code or how much code compiles doesn’t mean the code is actually running. Additional metrics that track the progress of the modernization are how much code is executing or code coverage, the impact of a new version of a code drop, and the overall project trends.

9. Claiming victory too early

Once the modernized application is in production, it’s tempting to sunset the legacy application as quickly as possible. After all, maintaining legacy applications takes resources that could be deployed on other strategic initiatives. However, the modernized application must be exercised in production for enough time to ensure that the migrated code operates as expected in the day-to-day operations. Sunsetting the application too early prevents a quick remigration using updated automation rules and instead forces a development team to prioritize, schedule, and address these issues manually during a development sprint.

10. Ignoring employee impact

Modernization is more than technology. It often triggers a fundamental shift in development processes and team organization, with many companies adopting DevOps principles, cloud deployment, and modern development best practices. It’s a sea change for the developers who are maintaining the legacy application. Therefore, it is essential to consider and plan for the impact on employees post-modernization.

About Synchrony Systems and our app modernization technology

We have reimagined how application modernizations are executed. Our technology has helped some of the world’s largest brands with assessments, readiness analyses, roadmaps, application migrations, and application transformations. Contact us today to learn how we can help you.

Challenges of PowerBuilder modernization

PowerBuilder is best known for its rapid application development (RAD) capabilities, particularly for building data-driven client/server business applications. It’s estimated that billions of lines of PowerBuilder code are running applications in North America alone, let alone globally.

PowerBuilder is considered to be a 4GL language. Key features of 4GL are a higher level of programming abstraction that is then used to generate the code into a lower-level language such as C or C++ and extensive components embedded into the language itself or its built-in system library. PowerBuilder is more of the latter than the former. Its WYSIWYG IDE with its event-driven programming model and all-in-one DataWindow presentation with powerful yet simplified data access CRUD capability, including sorting, filtering, computed fields, reporting, and other capabilities, is what gave it its claim to fame in its heyday.

Today, companies are looking to transform these applications to web and cloud environments to reap the benefits of their ubiquity, scalability, and global adoption. But what are the actual challenges of taking working, bespoke production applications written in PowerBuilder and transforming them into modern stateless microfrontends and microservices web architectures deployed in secure and scalable cloud platforms? Our modernization experts share some of the critical technical challenges teams face when undertaking such an endeavor.

Challenges modernizing PowerBuilder applications

Architectural differences

Generally speaking, PowerBuilder applications use a client-server architecture where the client handles much of the business logic and the server manages database access. Web applications, on the other hand, follow a more distributed architecture, often involving web servers, application servers, and browser-based web clients.

Splitting a monolith, especially a client-server, standalone, stateful monolith, into a web architecture is not for the lighthearted. Key challenges are:

Refactoring and decoupling presentation layout and logic from the underlying business model and logic.
Extracting application services into the web server tier and replacing direct access with REST calls.
Identifying interdependencies, interwoven user interfaces, and business logic and properly splitting it to work in the web tier.
Removing dependencies on stateful data access, such as open cursors and long transactions.
Last but not least, re-implementing the decades-old reliable software in new, and often multiple, new modern programming languages.

General code migration challenges

Modern web applications often use frameworks such as Angular, React, or Vue.js. Integrating the PowerBuilder business logic and data access layers with these frameworks requires significant refactoring and a very heavy lift in the absence of automation and refactoring tools. While dealing with a single PowerBuilder language, often target architecture requires multiple languages – JavaScript on the client and/or Java or C# on the server. In addition, PowerBuilder uses its own scripting language, providing additional capabilities for manipulating data retrieved from databases that may require a complete redo or an equivalent custom interpreter that will implement the equivalent semantics and functionality on the web.

Type safety and validation

PowerBuilder’s dynamic data typing allows flexibility but can lead to runtime errors. Migrating to a statically typed language involves enforcing type safety throughout the application, requiring an upfront investment in defining interfaces, types, and classes for consistent data handling and error prevention. Validation is often embedded inside the DataWindow objects and must be shifted to a mid-tier or form validation in the browser.

User Interface (UI) transition

PowerBuilder applications use a desktop-style UI with windows and dialogs that don’t naturally translate to a reactive web layout, especially for DataWindow 4GL-like components. Web frontend frameworks such as React offer rich UI components. Still, those components do not have all the equivalent properties and presentation semantics offered by the PowerBuilder’s rich set of controls and visual components and certainly do not provide a DataWindow equivalent functionality. If a like-for-like outcome is chosen, an initial step of modernizing a PowerBuilder application will require an equivalent DataWindow compatibility component framework to be implemented in the target web UI framework. For a more comprehensive modernization with the objective of achieving a native web UI/UX target, a more granular approach is necessary to break down the underlying data window-dependent behavior into separate independent pieces of display/presentation behavior, corresponding data access and data binding, and reporting capabilities.

Data access

The DataWindow is the PowerBuilder superpower. Its abstraction includes presentation (drawing and displaying forms that can have both simple and complex widgets), data access that includes SQL or stored procedure invocation, data binding, and transactions. A more comprehensive approach is needed to achieve functional equivalence on the web target with a smart, well-integrated compatibility library that sits on top of existing frameworks such as React or Angular. Adapting the data access layer to work with web technologies involves changes in how database connections are managed. The main challenge is the proverbial “thin-client” architecture, which implies statelessness. It’s not just that we are using different technologies for session management, connection pooling, etc.; the underlying transformation of the monolith into a microservices and microfrontends web and cloud architecture is where the real challenge lies.

Session management paradigm shift

PowerBuilder applications often rely on the session state maintained within the client application. In a modern web application, managing the client state requires technologies like Redux or another persistent data store on the browser side. Moving from a primarily client-side state management model to a distributed client-server architecture requires careful consideration of data synchronization. Depending on the application’s needs, data consistency and responsiveness are often achieved using REST APIs or WebSockets.

Performance

Whether the application is modernized for the web or built ground up for the web, it comes with the web territory of potential network latency in user response times and scalability depending on the demands of the underlying application profile. When modernizing a client-server architecture to the web, there is also the risk of potential consequential database “chattiness.” Once the application has achieved functional equivalence, attention must be placed on performance, overall application deployment, and scalability.

Security

There are differences in security practices for client-server applications and web applications. One of the most challenging parts of a PowerBuilder modernization to the web is extracting the application logic and, most importantly, the data access in the form of SQL and stored procedure calls to a web service layer. Once successfully split, other security layers, such as secure authentication (e.g., MFA, SSO), authorization protocols (e.g., OAuth, SAML, JWT), and data encryption and secure transmission (e.g., HTTPS), become more straightforward.

Overcoming these challenges

Addressing these challenges requires careful planning and a comprehensive modernization strategy. A phased approach to modernizing the application while maintaining its core functionality and user experience is often the best. At Synchrony, we go by the slogan, “don’t let perfection stand in the way of progress.” With our in-house advanced analytical tools, powered by code refactoring and code generation automation, we help streamline an otherwise very complex undertaking by simplifying its inherent complexity, reducing the risks associated with group-up overhauls, and ensuring that modernizations achieve functional equivalence and are completed at a fraction of cost and time with the absence of advanced automation.

Contact us to discuss your specific modernization needs or if you’d like to learn more about our PowerBuilder modernization experience and expertise.

Why modernize EGL applications?

Enterprise Generation Language (EGL) was a powerful tool in its time, but the technological landscape has evolved significantly. Modernizing EGL applications is crucial for businesses to remain competitive and agile.

Here are the primary reasons to modernize:

1. Improve user experience:

Outdated interfaces: EGL applications often have dated user interfaces that are not intuitive or mobile-friendly.
Enhanced user interaction: Modernization can create engaging, responsive interfaces that meet contemporary user expectations.

2. Increase efficiency and productivity:

Legacy systems bottlenecks: EGL applications might have performance limitations or scalability issues.
Automation: Modernizing can incorporate automation and AI to streamline processes and reduce manual effort.
Integration: New technologies enable seamless integration with other systems and data sources.

3. Reduce costs:

Maintenance overhead: Legacy EGL applications can be expensive to maintain due to limited skill sets and support.
Infrastructure costs: Modernization can reduce hardware and software costs by leveraging cloud-based solutions.

4. Enhance security:

Vulnerability risks: Older applications are often susceptible to security threats.
Compliance: Modernization can help meet industry regulations and data protection standards.

5. Unlock business opportunities:

Data-driven insights: Modernized applications can leverage big data and analytics for better decision-making.
Innovation: New technologies and platforms enable innovative products and services development.

6. Talent acquisition and retention:

Skill gap: Finding developers with EGL expertise can be challenging.
Attracting talent: Modernizing aligns the technology stack with current industry standards, making the company more attractive to skilled professionals.

7. Future-proofing the business:

Technological advancements: Staying up-to-date with technology is essential for long-term success.
Agility: Modern applications are more adaptable to changing business needs.

In essence, modernizing EGL applications is not just about updating the technology; it’s about transforming the business to be more efficient, competitive, and customer-centric.

We offer various solutions, including upgrades and transformations, to migrate your legacy EGL applications to a more modern architecture. Visit our EGL modernization page to learn more.

Brownfield software development guide

Brownfield refers to physical land requiring clean-up, upgrades, or development before leveraging the property for new purposes. Brownfield software development describes maintaining, upgrading, migrating, interacting with, or leveraging data from legacy applications.

Most of the world’s developers work on and within brownfield applications and environments. While greenfield software development gets the industry buzz, it’s the brownfield technologies with mass adoption and most usage that run companies.

Challenges in brownfield software development

Brownfield software development is not easy. The developers must keep brownfield applications up-to-date, transform critical legacy business logic to modern technologies, and architect interoperability between brownfield and greenfield applications and environments. Some key challenges with brownfield software to note are:

Not having a thorough understanding of the legacy applications and their dependencies with other legacy platforms
Staffing technical expertise to continue the development and maintenance of legacy applications
Developing a strategic modernization roadmap and rapidly executing it while reducing technical risks and business disruptions
Determining which parts of legacy applications are business-critical and must be preserved, maintained, migrated, replaced, or retired
Managing upgrades, migrations, integrations, and modernization of legacy applications in a consistent, uniform, and repeatable manner while continuing active maintenance (no halts in development).

The inability to adequately address these issues and challenges will have a costly impact on the current and future business.

Adopt continuous modernization to help solve brownfield application development challenges

Instead of the obsolete top-down / waterfall approaches in greenfield applications, development teams have adapted leading DevOps principles such as continuous integration (CI), continuous testing, continuous monitoring, continuous security, and continuous delivery (CD) to take a more agile and iterative approach. Incorporating the continuous modernization (CM) principle to brownfield applications should be a natural extension of DevOps to enhance and fully complete the cycle of software development, maintenance, and evolution.

The principle of continuous modernization is to avoid the need for large, time-consuming, costly, and risky undertaking of major modernization initiatives in the brownfield software space. Executing a continuous modernization strategy requires different processes and automation tools to manage software migrations, modernizations, and upgrades while coexisting with ongoing greenfield and brownfield development projects.

One such tool is MLP, a SaaS platform that brings a uniform upgrade process, a collaborative work environment, and transparent and traceable workflows to continuous modernization. It snaps into your existing CI/CD environments and procedures to give you the ability to apply new software updates systematically and incrementally to your in-house applications, APIs, or any other software components.

Benefits of continuous modernization for brownfield software

Leveraging automated modernization workflow management tools and platforms like MLP for brownfield software upgrades, maintenance, integrations, and modernizations will benefit the business in many ways. Some of the benefits offered by continuous modernization for brownfield applications are outlined below:

Accelerate adoption of native, cloud-first, and mobile application architecture
Fast-track digital transformation projects to accelerate delivery of business value
Reduce security risks associated with legacy applications
Keep currency with a rapidly changing technology landscape
Improve performance of brownfield applications
Continuously eliminate creeping technical debt
Prevent massive modernization initiatives in the future

In short, continuous modernization makes it easier to support brownfield application development by providing a systematic, uniform, and accelerated approach to executing modernization roadmaps without disrupting the day-to-day business operations.

Learn more about continuous modernization.

ModOps: DevOps for legacy modernization

DevOps has revolutionized software engineering methodology by unifying development and operations to accelerate software delivery. The older-style waterfall approaches to greenfield application development are being put aside as DevOps principles of agility, iteration, continuous delivery, and automation take center stage.

Modernization must deal with the challenge of transforming millions of lines of existing legacy code, built over decades by dozens, if not hundreds, of engineers, most of whom have moved on or retired altogether. Yet outdated approaches such as “rip and replace” are still the default modernization methodology, employing manual rewrites and disjointed automation tools. This approach is costly, takes an enormous amount of time and resources, and introduces significant risk to the business.

At Synchrony Systems, we believe it’s time to apply the DevOps principles, adopted for greenfield development, to software modernization—or ModOps—to keep pace with the rapid digital transformation.

Accelerating modernization delivery

Modernization focuses on transforming existing legacy systems and applications to the latest platforms and architectures. Unlike greenfield development, where very frequent and incremental changes are made to small bodies of code, modernization requires making wholesale transformations of the entire body of code at once and en masse. Therefore, the traditional manual approaches to modernizations can no longer be justified in today’s rapidly moving digital economy.

As the chart illustrates, ModOps accelerates modernization delivery and does so at a fraction of the cost and with faster time-to-value. It balances the overall speed, cost, quality, and risk while creating a unified experience that addresses a complex modernization process in a predictable way.

Continuous modernization

Continuous Development (CD), along with Continuous Integration (CI), have become the cornerstones of DevOps— the way applications are being developed and released into production. By replacing CD with Continuous Modernization (CM), ModOps will achieve the same—the way existing applications are to be modernized. Continuous Modernization will bring a high degree of automation and a systematic approach to managing the entire modernization lifecycle.

The three main pillars of ModOps are:

automation-driven modernization and transformation of legacy applications to modern programming languages and platforms;
coexistence of modernization activities with ongoing development activities, without any code freezes; and
functional and UX equivalency with no hidden costs or operational disruptions to the business.

ModOps is the answer for any company whose objective is to preserve its IP and its original investment in mission-critical legacy applications by adapting to and effectively competing in a rapidly moving digital economy.

As in DevOps, ModOps promotes agility, collaboration, and complete transparency. Project managers, migration engineers, testers, and other business stakeholders have full visibility into the overall status and progress of an ongoing modernization at every stage. With built-in planning, tracking, monitoring and dashboards, extensible workflows, automated testing and real-time feedback, a modernization is guaranteed to run smoothly and to be completed on time and on budget.

Tools for ModOps

The evolution of DevOps has spurred the development of tools to help teams more easily apply DevOps principles to the application development process. Modernization Lifecycle Platform (MLP) is doing the same for the application modernization process. It is a DevOps-driven, integrated, Modernization-as-a-Service platform that creates a unified approach to modernizing legacy applications. Whether it’s a modernization of COBOL to Java, PowerBuilder to C# or Smalltalk to Java, the underlying process, methodology, and user experience are uniform, no matter the chosen source and target platform combination. As a result, organizations are just months—not years—away from having their legacy applications transformed to the digital economy of web, mobile, and cloud.

No more legacy applications

We see a future where the application software is never “left behind” or lost to obsolescence. The major business challenges created by legacy applications—growing technical debt and shrinking technical talent—would themselves become obsolete.

Adding Continuous Modernization (CM) alongside CI/CD would give developers the ability to systematically and incrementally apply new software updates, adapt new APIs, or any other software components to in-house applications, thus doing away with any future wholesale modernization initiatives. By embracing ModOps and adopting a platform like MLP, businesses will become more agile, competitive, efficient, and responsive in addressing the demands of today’s digital economy.

How to pay off your technical debt (whitepaper)

Modernize your legacy code for a cloud-native world

Many organizations have already moved to the cloud. Yet the tech debt remains. Applications that were once considered “legacy” now run in modern infrastructure, but they’re still monolithic, tightly coupled, and difficult to change. Cloud hosting alone doesn’t make software cloud-native.

The business logic still matters. These systems still run underwriting, billing, claims, supply chains, and core operations. They cannot simply be replaced. But they can’t stay frozen either.

So what actually reduces tech debt? In this white paper, Jason Bloomberg, President of Intellyx, takes a practical look at legacy modernization — what works, what doesn’t, and where many organizations miscalculate.

Inside the paper:

Why lift and shift often fails to reduce tech debt
The architectural challenges behind monolith-to-cloud transitions
The limits of line-by-line code translation
Balancing automation with human engineering expertise
Why iterative approaches reduce modernization risk
The importance of scoping and lifecycle management in architecture transformation

If your cloud strategy hasn’t delivered the flexibility you expected, this paper offers a more grounded way to think about modernization.

Download your free copy of the tech debt white paper today.

Facebook TransCoder: a migration panacea or a mirage?

Last year Facebook announced TransCoder, a tool that converts code from one programming language to another. Like many companies, Facebook also has legacy code that runs critical features and functionality of their platform. They also have billions of active users. It’s no wonder they chose the automation approach for migrating their legacy code to more modern technologies. With this approach, Facebook can preserve its original investment and reduce the risk of significant business disruptions that the proverbial, brute-force rewrite would otherwise bring.

Facebook TransCoder Flow Image — Source: Facebook AI Blog

TransCoder can help modernize legacy systems; however, the devil is always in the details when trying to bring the migrated code to production quality, release the migrated legacy application into production, and retire it.

Any machine learning translation tool can only get the complete migration of an application so far. If Facebook’s TransCoder can translate 90% of the application code, one line out of every ten still needs a software developer’s attention.

For an application with ten million lines of code, one million lines of code would need to be hand-written with production quality.

A manual rewrite of 10% of a large application may take years. In fact, the translated code may never see a production environment. Even with Facebook’s size, virtually unlimited resources, and access to the world’s best talent, the company will still need to manage the entire software migration lifecycle and all of the pieces that it takes to bring the new code into production.

Modernization is more than just code translation

Machine-driven migration tools from source to target programming languages play a crucial role in achieving successful modernization projects. These tools are akin to best-of-breed compilers and their role in greenfield application development. Yes, we need a good compiler, but without the well-established best practices of DevOps, no compiler by itself can ensure the successful completion of a software development project.

What will it take to migrate a large and often complex body of legacy code that runs a critical aspect of the business to a modern technology platform and release it into production without any operational disruptions or development freezes?

This particular challenge has been the Achilles’ heel of every modernization project. No migration tools, including the TransCoder, make any attempt to even mention it or, let alone address it.

Tools like TransCoder are often positioned as “auto-magic.” Buy a piece of AI software, and *poof* all of the migration work is done in a few keystrokes. But a programmer cannot take a COBOL program, wave an AI wand over it, and turn it into microservices or properly architected modern-day application. Right now, AI tools are decades away from being able to transform legacy applications in this manner.

Migration tools inside a modernization process

Migration tools such as TransCoder are just pieces of the chain of moving parts needed to run a well-oiled machine of an otherwise complex modernization process. Therefore, the real value is in integrating such tools inside the entire modernization lifecycle to achieve the kind of an assembly line that is needed to make a complex modernization manageable in terms of process and predictable in terms of time and cost.

No single automation tool is a silver bullet for a modernization project, and we should know. We’ve spent 25+ years modernizing legacy applications, building and using our proprietary migration tools. When we finally managed to integrate the source code migration tools into an entire modernization process, our clients saw considerable gains in code quality, efficiency, and affordability.

Our Modernization Lifecycle Platform (MLP) supports the entire modernization lifecycle: from analysis and planning to transformation and remediation; from build and deployment to testing and production release. It applies the same systematic, iterative, and automation-driven modernization processes to produce production-ready, modernized applications. It is compatible with any translation libraries or rule-sets, no matter the source or target programming language, platform, or framework. By automating the complete modernization process where a tool like TransCoder can be integrated into as part of an entire assembly line, the MLP platform:

Saves thousands of hours of manual effort
Reduces the time and cost of a modernization by 90% compared to traditional approaches
Is 100% automation driven yielding predictable outcomes
Ensures 100% functional equivalence
Eliminates the risk of introducing unexpected regressions or random defects
Provides complete transparency and interoperability for all stakeholders

Like Facebook’s TransCoder, new tools are emerging to take on challenges evident in legacy application modernizations, but they are limited in and of themselves.

An integrated platform that facilitates an automated, reliable, and transparent modernization while ensuring 100% functional equivalence with no operational interruptions is needed to take the migrated application into production.

MLP delivers what TransCoder only promises.

How to prepare for legacy application modernization

In-house applications, once associated with good fortune, have now become an albatross. These systems may still run business-critical processes or orchestrate data between commercial systems, but their underlying, aging technology has become a real liability. You know it’s only a matter of time before something fails, and it won’t be pretty.

You may be hearing a lot of bluster about the best way to go about modernizing legacy applications. “Refactor,” “re-platform,” “encapsulate and expose for microservices,” “lift and shift,” and “low-code rebuilds” are just a few of the buzz-phrases floating out there. At Synchrony systems, we also have our own view of how best to modernize. But the how is not always as straightforward as some try to make it seem. How to modernize depends on many factors that span well beyond source code or target technology.

So where do you begin? The following steps should not only help you prepare for legacy application modernization; they also should help you clarify the right modernization methodology to pursue.

Know what you have: document your current state

While this may sound like a no-brainer, you’d be surprised at how many companies don’t have a complete, up-to-date overview of their technology stack. Perhaps that’s because they’re busy putting out daily fires or launching new initiatives. Or maybe staff turnover put the critical, technical documentation on the back burner. Regardless of the reason(s), before starting any potential modernization initiatives, you must possess a full technical understanding of your IT portfolio and which parts of it are mission-critical to your business operations.

Three dimensions of the current state must be well understood: architecture, timeline, and capital.

Architecture: While it’s ok to not have all the answers, accurately describing what you know—and highlighting what you don’t—is important.

Do you have access to the source code of your in-house applications?
Do you understand your applications’ source platform dependency?
Do you understand your applications’ component architecture?
Do you understand your applications’ runtime architecture?

Timeline: Many in-house applications are built using licensed, 3rd-party software. Understanding the timing of the maintenance and support contracts is an important input to the modernization effort.

Capital: Capital includes the dollars used to support the in-house applications, as well as the resources and time spent maintaining them. You also need to understand what other IT projects your company is currently funding, the budget for the modernization initiatives, and when those funds will be available.

With this information, you can start to map out the priorities for your modernization.

Know where you want to be: document the future state

Sometimes the future state has a strategic mandate from the top—become cloud-first or consolidate technologies onto a single platform. Other times, the future state evolves more organically. Regardless of the path, you need a documented roadmap of the new vision for IT. This plan is really a risk-mitigation strategy for your legacy applications. It’s only a matter of time before the old versions start to fail, their security gets breached, a 3rd-party vendor stops supporting the software, or some other business-impacting event occurs.

Like the current state, your future state plan has the same three dimensions: architecture, timeline, and capital.

Architecture: Future state technology architecture needs to be aligned with the business need, and not just be technology for technology’s sake. The tech vision must map to the business vision and support the business value of investing in modernization. Along with technology, the future state should include recommendations about the people and process changes required to operate in this new architecture.

Timeline: Modernizations can be lengthy projects with many concurrently moving parts. A strong roadmap includes critical dates such as contract renewals, end of support, and/or end of life. It includes budget cycles for funding, and it maps critical hires such as short-term contractors, modernization specialists, and/or full-time developers/IT professionals. The roadmap also should include important business dates like acquisitions, major product launches, peak selling seasons, etc. All these factors can help shape your modernization priorities and urgency.

Capital: In addition to the investment allocation for the initiative, you also need to understand the capital outlay needed for resources—internal and external—required for success.

Determine the path forward

Now you can perform a gap analysis of the current and future states. The timeline and available capital will be key factors—the “how”—that inform your approach to modernization.

Another factor to consider is the relative effort of modernization. For example, rewriting an application from scratch is not only time-intensive from a greenfield development standpoint, but the effort to make it operational would include retraining users, rewriting documentation, re-tooling support, etc. Many hidden costs of rip-and-replace strategies that may be overlooked during the initial scoping will later become quite burdensome.

For very small, in-house applications with minimal business impact, simple migration tools may be all you need for the modernization. For very large, in-house applications, the strategy may be more complex and consist of several approaches, including:

Rip and Replace: replace with an off-the-shelf alternative
Lift and Shift: re-platform or re-host the entire legacy workload onto a virtual cloud environment
Rewrite: retire and invest in ground-up greenfield development
Re-architect: attempt to improve in place the underlying legacy application architecture into a more modern, service-based, web architecture.
Migrate: using automation, migrate “as-is” to a new target platform, preserving functionality and user experience

At this stage, talking with companies that specialize in modernizations is a wise idea. With the groundwork you’ve done, modernization experts should be able to give you a proposal for moving forward, a timeline, and a cost estimate for the modernization.

Start now

As Benjamin Franklin once said, “By failing to prepare, you are preparing to fail.” It’s never too early to begin the work necessary for a clear strategy to move away from your legacy applications.

At Synchrony Systems, we have over two decades of experience helping companies modernize their legacy, mission-critical applications in the most cost-effective and transparent way possible. Whether you are just starting to think about modernization or have an urgent need, we are happy to talk with you about your specific situation.

Smalltalk application modernization technology

Smalltalk is a dynamic programming language and a pioneer in object-oriented technology. Its versatility, simplicity, and elegance allowed people to rapidly build complex systems across a variety of industries and applications.

Although other programming languages surpassed Smalltalk in popularity for commercial application development, few captured its unique capabilities.

This makes Smalltalk applications difficult to replace without giving up design and functionality.

The trusted experts at Synchrony Systems have spent over two decades developing technology to address the unique challenges in modernizing Smalltalk applications. Our solution fast tracks Smalltalk modernizations to meet digital transformation demands while preserving the functionality and elegance of the original design. Our solution is designed to prevent operational disruptions — no code rewrites, no code freezes, no halts in development.

Previously, dynamically-typed systems were not good candidates for migrations.

Today, Synchrony’s Static Typing Engine makes these migrations possible. It’s the only proven solution in the market that turns dynamically-typed Smalltalk into statically-typed Smalltalk. It accurately identifies live code and isolates execution paths that are then rapidly migrated or deprecated. The analytical capabilities of our solution give you complete visibility into the Smalltalk interactions within your system. This allows you to extract functionality and migrate it to properly architected microservices.

The entire Smalltalk modernization process is managed through Synchrony’s Modernization Lifecycle Platform. MLP provides an automated, incremental, and agile modernization experience for all stakeholders–from analysis and planning to transformation and remediation to build and deployment to testing and production release. All without impacting the production version of your Smalltalk application or interrupting your day-to-day business operations.

With Synchrony, drastically reduce the cost and eliminate the risk and failure that comes from a rewrite with the most advanced Smalltalk modernization solution on the market.

Ready to launch your Smalltalk into the future? Contact Us.