Orchestrated RPA: Bridging the Gap between Legacy Applications and Optimized End-To-End Automation

When it comes to achieving optimized end-to-end automation, most businesses aren’t starting out in a green field. But integrating large legacy applications into capable orchestration platform solutions can be challenging for a number of reasons. And robotic process automation (RPA) can be super helpful.

Legacy systems often lack the necessary APIs, implementing them can be costly, and the newly integrated system that needs to call, for example a REST API, must also have access to it, which might not be possible due to firewalls, or often simply isn’t desired. An external worker pattern integration doesn’t require the legacy system to have a REST API, but it still requires the ability to call one.

Other integration methods, such as using event systems — or messages — typically require additional development on both sides as these must be produced and consumed. And unless integrating with a low-code platform, most applications lack generic APIs for this purpose, making such integrations cumbersome for legacy systems. 

How can RPA integration help?

Typically when integrating with a legacy application, only a user interface is available for manual control of the system, without APIs. 

And these applications are often developed in programming languages that make it difficult to find skilled professionals to further enhance the software. Even if the right person is available, modifying systems that have been running for a long time carries significant risks. As the saying goes, “never touch a running system.”

This is where RPA steps in, aiming to solve the problem by leveraging the user interface to automate tasks. While it’s a quick way to automate processes without an API, it’s not how you’d ideally implement an entire process. The RPA layer simply adds an interface on top of your legacy application; it’s not the tool that will modernize your application.

It might be worth considering replacing the system in the future with a modern one, and at that point, abstraction becomes helpful. That’s why integrating RPA into a low-code or business orchestration platform like Flowable is a great approach. 

The Flowable RPA integration

Flowable integrates with best-of-breed RPA technology. One of these tools is the RPA Framework. The RPA Framework allows the development of ".robot" files, where the system's actions can be specified without programming — such as clicking on a specific position or element on screen, or typing specific characters on your keyboard.

This comes in handy when used together with Flowable. Certain tasks can be automated in Flowable, and it’s possible to simply drag and drop an “RPA Framework task” onto your canvas to execute specific steps. It allows you to perform modern integrations for modern systems with a low-code editor, while integrating legacy systems.

Under the hood, the RPA Framework integration uses the external worker pattern. This provides multiple advantages:

• The legacy application doesn’t need to be exposed; it simply fetches the information it needs and returns it.

• Multiple instances of the legacy application can run at the same time and concurrently execute jobs — if the legacy application supports it.

• Usage is possible on different operating systems and in different network zones, as long as the system can communicate with Flowable.

• No custom software needs to be developed.

How to use the RPA Framework integration

As the RPA Framework is based on Python, Python must first be installed to use the RPA Framework integration. The Flowable integration also uses Python, so no additional runtime environment is needed, and it can be used across systems.

Once Python is installed, the RPA Framework (rpaframework) and the Flowable RPA Framework client (flowable.rpaframework-client) can be installed.

To use the RPA Framework, it is required to establish an authentication connection for the client. This can be done either by issuing a bearer access token or by providing a username/password combination.

With a robot file and different tasks in it, you can use the RPA Framework task in Flowable Design to model a process. In the RPA Framework task, a task name must be specified, which matches the task name in the .robot file.

Next it's necessary to publish the application and start the Flowable RPA Framework client on the machine where the .robot file is to run. Once done, the process/case is ready to be executed.

Looking at an example integration

Let’s scale down from a legacy application for a moment to a simple example: an Excel sheet. While this might not seem realistic, it is surprisingly common for companies that have grown to rely on one or more Excel files within their business process management, often even with some macros automating data sets. And while it might be planned to revamp data management, the desired time to market is often too crucial to completely replace a legacy system before getting new automation processes up and running in the meantime. In our example, the Excel sheet calculates the value of a company based on its cash flow. The math behind this is simple and could be done using expressions or a script within Flowable itself. This example is used to illustrate the capabilities of RPA Framework integration. We begin with a simple process:

In a real-world scenario, there would typically be additional integrations to transmit the result to another system. The RPA task (“Calculate Value”) is configured with a job topic and a specific task name:

There are also certain inputs and outputs which can later be used inside the RPA Framework execution:

This is the excel file used for the calculation of the cashflow:

To execute the task, a “companyvalue.robot” file is required with the definition of the “discounted_cash_flow” task:

*** Settings ***

Library    RPA.Tasks

Library    RPA.Desktop

Library    flowable.rpaframework_client.API

*** Tasks ***

Discounted cash flow

${fc1}=       flw input  fc1

${fc2}=       flw input  fc2

${fc3}=       flw input  fc3

${wacc}=      flw input  wacc

Open Application open  -a /Applications/Microsoft\ Excel.app

Click         image:images/fc1.png  click

Press keys    right

Type text     ${fc1}

Press keys    enter

Type text     ${fc2}

Press keys    enter

Type text     ${fc3}

Press keys    enter

Type text     ${wacc}

Press keys    enter

${terminal_region}=   Find element image:images/terminal-value.png

${moved_t_region}= Move Region ${terminal_region} 205 0

${terminal_value}= Read Text  ${moved_t_region}

${company_region}= Find element image:images/company-value.png

${moved_c_region}= Move Region ${company_region} 205 0

${company_value}= Read Text  ${moved_c_region}

Take screenshot

flw output    companyValue   ${company_value}

flw output    terminalValue  ${terminal_value}

In this file, a few elements are defined:

1. Import of libraries, including the Flowable RPA Framework Client API.

2. Definition of the task “Discounted Cash Flow” (this is the name referenced in the process).

3. Read the inputs from Flowable into local variables.

4. Ensure that Excel is in focus by opening the application (assuming the Excel sheet is already open).

5. Search for “FC1” in the Excel sheet on the screen using a picture.

6. Click on the searched position to hit the field next to the first number.

7. Move to the right and fill in the next numbers using the keyboard.

8. Read the result from the screen.

9. Write the output to be consumed by the external worker task in Flowable.

Note: For this specific file above you need to install the additional recognition locator from the RPA Framework (rpaframework-recognition) and Graphviz (graphviz).

Once the file is created, the RPA Framework Client can be started:

python -m flowable.rpaframework_client --flowable-token <your-token> calculateCompanyValue companyvalue.robot

While the “calculateCompanyValue” must match the job topic configured in Flowable Work, the file “companyvalue.robot” is the file created earlier. This example assumes that the Flowable Trial is in use and connects automatically to it. Once the client is started, it polls the Flowable Trial to consume new external worker tasks. When a process is created, a job will be executed, and the result will be reported back to Flowable.

In case you want to connect to your own Flowable installation or would like to know more about the RPA Framework client, you can check out the GitHub project.

A powerful approach to modern process automation

Integrating RPA with Flowable provides a powerful approach to bridging the gap between legacy systems and modern process automation. While traditional integration methods like REST, events, and external workers are robust, they often fall short when dealing with systems lacking APIs and flexibility. By leveraging the RPA Framework, Flowable enables businesses to incorporate legacy systems into new automation strategies, ensuring that even systems with only user interface accessibility can be automated effectively.

Flowable’s low-code platform, combined with RPA technology, allows businesses to design, orchestrate, and automate processes in a streamlined manner. This synergy not only minimizes the risks associated with modifying legacy systems but also accelerates automation without heavy custom development. With a focus on adaptability, scalability, and ease of use, this integration equips organizations with the tools to modernize their operations while preserving existing infrastructure. Whether tackling legacy challenges or optimizing current workflows, the Flowable RPA integration demonstrates the potential of marrying innovation with practicality.