AOT Supercharges with Robotic Process Automation

  • Case Studies,
  • How-To,
  • News

Speed the Process and Cut the Tedium

Shifting tedious tasks from humans to robots saves time and money, and often increases reliability. Robotic process automation (RPA) is a form of business process automation that takes full advantage of the speed and reliability of “bots.” When matched with the power of, a forms workflow can trigger an RPA process. Once a form reaches a particular stage in processing, can initiate automated behaviour including the execution of RPA commands. Voilà! Time and money saved!

We’ll give you a bit of background and an example: performing an online background check of someone who’s applied for a business licence.

Boosting Camunda’s Workflows with Robots is a completely free and open-source framework built and maintained by the AOT Technologies team to integrate intelligent forms, decision-making workflows, and powerful analytics. While working with various clients who needed forms and workflow management, the team recognized the usefulness of triggering external tasks from outside of the ecosystem.

For creating and executing decision-making workflows, uses a powerful Camunda BPMN, which supports external service tasks that can be extended to automate tasks. makes use of this powerful external task client to process the robot’s instructions and return a response. That’s how Robocorp’s RPA came to be integrated with (Note: you can click on any image for a pop-up view.)

RPA is just one of many integration options that help strengthen the power of

RPA, or robotic process automation, is a hot topic nowadays. It’s a type of business process automation technology making it easy to build, deploy, and manage software robots that mimic human interactions with digital systems and software. Just like normal users, software robots can do such things as understanding what is on a desktop screen, autofilling data and entering keystrokes, navigating through systems, identifying and extracting data from different sources, and performing a wide range of defined actions.

The team had been searching for an RPA solution that would meet the following criteria:

  • Was open source
  • Had good support for the tools and libraries that would build and deploy the robots
  • Was easy to use

After checking various options, the AOT team chose Robocorp’s RPA solution.

Doing Robots the Robocorp Way

Robocorp supports automating any system that a robot has access to, be it a desktop application, API, mainframe, database, FTP server, or an image stream of the user interface. Robocorp gives you the tools to build and deploy the robots according to your requirements, unlike predefined robots offered by other RPA solutions. And on top of everything it’s an open-source solution.

By partnering with Robocorp, AOT Technologies has been able to incorporate Robocorp’s RPA system and extend the power of Camunda’s External Service Tasks, also known as Camunda Workers.

Camunda is the business-process component of, allowing the user to define workflows and associate them with your online forms. By integrating with Robocorp, Camunda’s powerful features become even more powerful through the power of automation.

With our latest enhancements, now offers built-in compatibility with Robocorp’s open-source RPA framework. The framework offers a configurable robot with audit and history options—and supports both cloud and command-line robots, input and output operations, and multiple operating systems including Windows 10, LInux, and Mac. Typical use cases of the framework are web scraping, automating tedious tasks, and batch converting files into PDFs.

The RPA-Robocorp-Extension

RPA-Robocorp-Extension implementation details can be seen in this GitHub repo.

Let’s start with installing the Camunda RPA client. There are two installation options, one standalone, the other Docker based.

For a standalone installation you’ll need Java, Maven, the Robocorp RCC toolchain, and a cloud account.
For a Docker-based installation, you’ll need to install Docker if needed, and get Docker up and running. You can then modify the variables and run the application in Docker.

Now let’s look at the system architecture:

As you can see in the architecture diagram, there are two components: the Camunda service task and the external RPA client.

We are using Camunda’s powerful workflow feature called a service task, which can serve as an event in a pub-sub (publish/subscribe) model, with a unique topic assigned to it. Once Camunda publishes a piece of data, the external task client (developed using the Camunda extension) can pick up the task and execute the job in the following order:

  1. Capturing input data.
  2. Performing a timely audit.
  3. Getting the robot’s configuration details.
  4. Running the robot.
  5. Capturing the response.
  6. Completing the task.

Authentication Manager

The RPA system has to maintain a constant connection with Camunda in order to process the request and execute the robot. So in order to establish a secure connection the RPA client needs to authenticate through Camunda. The RPA system has built-in options for configuring a type of basic authentication or a Keycloak-based token authentication

Robot Data Manager

The robot data manager is the primary datastore for recording an audit history to know if a robot was successful, and if it wasn’t, to provide information for debugging such as how long it took the robot to complete its tasks and other analytics.

Robot IO Manager

A robot can be triggered with or without input parameters and the same applies to output. The output can be of different types including primitive type data, single files, multiple files, and an empty response. The output can be configured and handled only using a robot IO manager.

Robot Manager

A robot can be started using the robot manager, which identifies the path that contains the robot’s instructions and runs the robot using an API or command-line tool depending on the configuration provided.

Robot Pipeline Service

The robot pipeline service comes into picture when RCC is configured as the execution environment. In that situation the service can create a pipeline or bridge between the command line and the Java API.

Sample Use Case: Background Check Verification

In collaboration with Robocorp we developed a way to automate background checks on business-licence applicants by having a robot perform web scraping. Here’s how we did it:

Step 1: Build the Robot

First, you need to create your robot using the Robocorp framework. In particular, we’ll be using Robocorp Lab, which provides open-source components as an easy way to get started developing software robots.

Our background-check robot first extracts a business application form’s input variables before starting the web scraping. It will then record screenshots of pages in the following categories before compiling these shots as a PDF file:

  • The company’s social-media profile on such sites as Linkedin, Twitter, Facebook, and Instagram.
  • The business’s working website, if it has one.
  • Google’s search results about the company.
  • Checking if the company is blacklisted, presuming it’s opening up in Canada.
  • The PDF file can be downloaded in by the Reviewer of the application form, and then sent on for an Approver’s response.

Step 2: Create the Camunda Workflow

Next you’ll create a Camunda workflow that includes a two-step approval process:

  • Create a process diagram with an external service task using Camunda Modeler and define the topic name.
  • Then deploy the process to the Camunda platform engine.


Step 3: Use External Task Handler to Link Robot to Camunda

We need to create an external task handler for each robot. The task handler uses the Camunda REST API to fetch, lock, and complete all the required external service tasks. We can configure the Java handler to custom override all the methods needed to manage and run the robot. This process relies on an external task subscription. Also, you will need to define the topic name as shown below. The topic name should be similar to the robot name.


Step 4: Create the Form Using

Next you’ll create the form using the drag-and-drop interface of the design mode. Log in as a Designer using the form design page.

Step 5: Associate a Workflow, then Publish the Form

Once you’ve completed the form design, publish the workflow to Camunda and associate the form with the workflow you created in step 2.

We can then publish the form you designed in order to make it available for clients to fill out.

Here’s an example of how a client filled out a sample business licence application:

Step 6: Start the Robot

After the form is filled out and submitted, the associated workflow will be triggered, and an external service task will then start the robot. You can run your robot either directly by using RCC or indirectly by starting a cloud instance.

Step 6A: Using the RCC Method

RCC is a set of tooling that allows you to create, manage, and distribute Python-based self-contained automation packages.

Configure your robot type to ROBOCORP_RCC so the robot will run using the RCC method. To run Robocorp RCC directly, you have to add your robots to your resources folder.

After the user fills out and submits the form, the robot will be triggered and will do its task.

With RCC you can use parallel robot invocation by placing your robots in multiple holotree spaces. It’s not a complete parallel solution as you’ll have to keep in mind that each robot runs only once until it receives a new request.

Here’s a sample run:

After the robot has completed its task, the response file can be downloaded from the form’s page in

Step 6B: Using the RPA Cloud Method

If you’re using the cloud, you’ll need to set up a cloud account and provide your robot type, workspace ID, and process ID to ROBOCORP_CLOUD. You can run multiple processes here, or choose parallel execution.

All aspects of your robot workforce can be controlled in the cloud, including triggering the robot, uploading and downloading robots, monitoring their status, and getting the results of their work through simple API calls.

Here’s an example:

Once the new business licence form has been submitted, the cloud-based robot will be triggered and will start processing:

You can monitor your robot’s activities in the cloud and afterwards check the logs in your workspace:

Step 7: Download the PDF Report

After the robot has completed its task, a response file will be created. Below you can see a sample PDF that was generated by the robot using our sample form data and then downloaded from the forms page on

And here you can see the link for downloading the PDF:


Step 8: Finishing the Approval Process

The downloaded file can be reviewed in by a user in the Reviewer role, who can then either Reject the form or mark it as Reviewed with Comments.

Challenges Integrating Robocorp with

There are many great features that Robocorp integration offers. However, you should remember that parallel robot invocation is a bit limited. Each robot will only run once until it receives a new request.

Future Integrations

Automating tedious manual work can let companies more effectively utilize their resources and increase their profit. In the next few years RPA has the potential to replace a great variety of manual tasks performed by people, who can then focus on scenarios requiring more nuanced human judgment. Ultimately RPA can be applied anywhere there is a tedious manual task, which could range from simple web scraping to data migration and validation.

About the Authors

Abhilash K R is the technical lead at AOT Technologies currently heading the team in India developing, an open-source, low-code forms-and-workflow solution. He is a full-stack developer and JavaScript wizard with over eight years of experience in technologies such as Angular 1.x, React, Angular 2+, Node.js, and Ionic. He loves travelling and getting into gaming when not in the coding hood.

Shibin Thomas is the technical lead at AOT Technologies currently contributing to, an open-source, low-code forms-and-workflow solution. He is a full-stack developer with close to nine years of experience in developing and designing highly scalable solutions. His key focus areas are Java microservice development, cloud projects, and SQL. He loves travelling and adventures, and dreams of climbing Mt. Everest some day.