Most, if not all, enterprises consider “Digital Transformation” as one of their top-priority challenges. During the last several years, enterprises have been developing standalone digital applications and digitalizing peripheral systems. They now understand that this Digital Transformation must expand to include their core business processes themselves. Such transformation cannot take place without integrating the digital interface with their existing enterprise systems.

Existing legacy integration tools and methodologies are based on the 20-year-old concept of turning relevant pieces of legacy code into services. However, for many underappreciated reasons, “service-oriented” integration imposes heavy constraints and limitations that yield to less than ideal digital processes.

Enterprises have launched their most strategic process in decades without realizing that they have an inappropriate toolset at their disposal.

Legacy Integration Solutions do it Wrong

Legacy systems are based on two interrelated principles:

  • They are stateful:
    • Validations, calculations, and data manipulation depend on cumulative data, collected or computed in earlier steps of the application execution.
    • Many legacy systems to expedite performance and facilitate programming load a large set of constant data during application initialization and use it throughout execution.
    • Database connection is usually established upon application launch and closed on exit.
  • They are procedural. Their internal data model typically reflects database structure rather than business objects — not to mention, isolated, well-defined methods for manipulating them.

Nevertheless, modern tools and methodologies insist that legacy modernization and digital transformation should be based on wrapping pieces of legacy code into services: “SOA,” “Web services,”“micro-services,” “Services via API,” etc. In other words, turning stateful, procedural programs into stateless classes…

Services libraries typically provide one of the two types of services:

  • Expose data selected and manipulated by the legacy system.
  • Process some business logic.

Wrapping legacy code into a stable library of services is a complex, long, and expensive process that requires a wide skillset of both business subject-matter expertise, as well as modern technologies experts.

Due to the complexity of identifying isolated pieces in the legacy system, very often the minimal feasible granularity of such a service is an entire business transaction.

The dependency on services’ availability and granularity makes it practically impossible to build a reasonable digital application without writing a significant amount of redundant code.

The need to capture and process all preliminary code and data in every stateless service usually has a severe effect on performance.

Consequently, core business process digitalization becomes the development of brand-new applications that at few points extract data from legacy systems and (many times only at the end of the business process) call business logic processing services. Such behavior contradicts most fundamental UX principles.

In summary, service-oriented legacy integration is risky, long, and costly. Most importantly, it imposes severe limitations on the quality of the resulting digital application.

There is a Right Way

Mosaics offers a revolutionary alternative.

It provides a tool that after some minor, one-time adjustments to the specific legacy application, automatically peels off the code that interacts with the exiting screens (i.e.,what users see and how they can enter input). It then replaces it with a standard interface that can communicate with any external source. The external source can provide the input expected by the legacy program in order to smoothly execute the existing business logic.

This turns the entire legacy application, at once, into a set of paths. With the appropriate input, these paths can lead the execution of every single piece of the entire application — from end-to-end.

Mosaics assigns each source (e.g., digital user session) a dedicated, stateful connection to the “path-driven” version of the legacy application.

The legacy code can be called at as many points as needed, even at the smallest granularity. Each call executes a part of the collective set of paths required to perform the relevant business task in the legacy system. Repetitive paths, as well as sequences of steps that do not require any user discretion, run automatically without any user intervention (“behind the screens” robotic process automation).

The integration process consists of defining the paths and attaching them to the right places along the digital interface. The analysis is done by running the existing legacy system (as users, not as programmers) and documenting the paths and input required to complete the business task. Obviously, this must be handled carefully and takes time. However, unlike any other applicable alternatives, it does not require any code analysis and restructuring. The process is in an order of magnitude less complex, significantly faster, and requires less testing and maintenance.

Ongoing development and maintenance of the legacy system continue just as usual, by the same team and according to the same development practice. Performance is optimal, and there is no need for any redundant development.

And the most disruptive benefit? Mosaics can design and generate the optimal digital interface that perfectly reflects the way users should do their work, without any limitations imposed by the existing application or underlying technologies.