Robotic Process Automation (RPA)
As described throughout the documentation, KuFlow is a platform that allows you to orchestrate business processes involving work performed by people and work performed by automation. It happens that many times, our processes are made up of repetitive human tasks that users perform as if they were machines. So, wouldn't it be great to have a robot assistant to whom we could delegate those tasks? Obviously the answer is yes, and that is why KuFlow has mechanisms that allow the coordinated execution of RPA (Robotic Process Automation) processes in the resolution of business processes.
This section addresses the different possibilities that KuFlow offers as an RPA orchestration platform based on different technologies. For implementation details and examples, see the developers section.
Assisted and unassisted robots
We need to differentiate two types of robots based on their need for interaction when receiving inputs during their execution.
Assisted automation
This type of RPA requires human interaction at some point during its operation. That is to say, although most of the work will be automation that imitates user actions (for example mouse clicks), at some moments of the robot's execution human interaction will be required. A classic example is asking the user to log in to a web or desktop app with their personal access credentials and from there, the robot performs the necessary business automation. In short, it requires that a person be in front of the computer at the time of its execution.
Unassisted automation
As can be inferred from the name, this type of RPA does not require a person to be in front of the computer. That is, once the execution of the robot begins, it has all the necessary information (or can access it) to carry out the work.
Based on these two categories, inherently underlies the answer to the question, in what execution environments are these types of robots deployed?
Unassisted robots may be deployed on client servers. That is, they are executed in a coordinated manner through a Worker that supports our business cases. This facilitates deployments and error control since the servers are homogeneous environments, controlled by qualified personnel, highly available and whose growth (numbers of deployments) is always under supervision.
On the contrary, assisted thefts need a different approach, they need to be deployed in the users' personal environments, that is, on the personal computer of the user who will run this type of robots. This opens up a wide range of administration and support tasks for users. However, KuFlow, to limit these tasks as much as possible and make the installation and execution of these robots more flexible, makes available to users a desktop application (KuBotManager) that allows the robots to be installed and run in just a few clicks. The operation of this use case would be as follows:
- The developers design and implement the robot.
- Process administrator upload a package with the robot code to the KuFlow web application and assign usage permissions.
- Process administrator design their processes in the usual way, creating tasks, assigning access permissions, and selecting which robots execute their tasks.
- End users or organization administrators install the application provided by KuFlow on their personal computers. This application can be obtained as a direct download or in marketplaces such as the Microsoft Store.
- The user runs the application, logs in with their KuFlow credentials, and is shown a list of available robots to which they have been given access.
- The user installs the robots he considers by clicking on them. After completing the installation, the robot is ready to receive work orders.
- In the KuFlow web application, when a process is assigned a task to a user, after being notified, the user accesses the web app and presses the run robot button.
- Next, the user receives a notification on their personal computer that the robot is starting to run and will be required to interact with it when the robot implementation requires it.
Choosing the most appropriate solution
Sometimes it is difficult to determine which is the appropriate solution when implementing business processes. The decision can be made based on multiple criteria. Some are inherent to the structure of the client organization such as the technical capacity of the development team, the available infrastructure or regulatory requirements. Another group of criteria is based on the use case to be implemented, how users are involved and access resources needed, among others. All of these issues may have a different weight depending on each organization. This section details some issues to take into account when deciding if I need RPA work for my business processes and, if so, what is the most optimal way.
Issues to consider:
- Does my process need to access external resources such as third-party APIs, websites or internal client applications?
- Does my business process contain tasks that can be implemented through repetitive technological automation?
- Do the external resources you can access have standardized access APIs?
- Do the automations to be implemented need to be attended to by a human during their execution?
- To access authenticated resources (websites, APIs, apps) is it necessary to have personal credentials or are there service credentials?
- To help you in your decision, the main criteria have been summarized in the following diagram:
KuBot
KuBot is the name we give at KuFlow to RPAs that perform assisted robotic work on behalf of a human.
A Kubot is nothing more than an executable application on a system along with a set of manifests that govern its provisioning and operation. For example, a minimalist case of KuBot could be a command-line binary program that prints a “Hello World” to the console, along with instructions on how to invoke that process.
This mechanism, at first glance simple, allows us a wide range of possibilities when it comes to implementation. For example, it is completely agnostic of the implementation language, and can even be written in interpreted languages such as Python, or that use virtual machines such as Java, in any compiled language, etc.
KuBot Manager
It is a desktop application (Windows) that allows the provisioning and execution of KuBot in users' personal environments, as part of a job in a business process.
Allows you to install the KuBot to which the logged in user has access. Once a Kubot is installed, it is ready to receive jobs from KuFlow. The application can be kept minimized to the system tray and will continue to receive jobs.
Likewise, each time a job is carried out, the appropriate system notifications will be launched. The user will also be notified of possible pending updates to the KuBot as well as the application itself.
The app is available for download free of charge through the Microsoft Store.
RPA technologies and their integration with KuFlow
Although you can always develop your robot from scratch, like any other application, you can use a specific RPA platform in your development. There are different RPA solutions on the market that can be used in integrations with KuFlow. From the most basic point of view, any product can be integrated since one of the actions that we can implement from a worker is to invoke an external process and have it interact with the KuFlow Rest API. However, this approach is very basic and the developer should implement external process management and communication mechanisms on their own. Likewise, if you want to bring robot-produced outputs to your process in KuFlow, you must integrate a Kuflow API client into your robot.
To assist in robot development, KuFlow provides within the available SDKs different tools for integration that may be relevant based on the RPA solution adopted.
In order to cover an explanation of integrations, we will focus on solutions based on Robot Framework, Robocorp, UiPath and UI.Vision.
Robot Framework
Robot Framework is an open source robotic process automation (RPA) and test automation framework. The framework has a keyword-based testing approach, allowing users to create tasks in a natural language syntax.
To facilitate the integration of these processes, KuFlow has an open source library that provides useful keywords for connecting with the KuFlow app and manipulating processes and tasks. The library is available on Pypi and the source code is available on our GitHub.
Robotcorp
Robocop is an automation platform that allows you to run robots from your own control panel. However, it also makes available a set of open source libraries that are useful for developing robots. In the beginning, they used RobotFramework as an RPA engine and around it they developed a library, current today, with numerous keywords to use in robots. This framework is known as “rpaframework” and is also open source. Many of these keywords are a simple wrapper with Robot Framework syntax on top of many other third-party libraries and resources.
Recently, they have developed new utilities to run robots without having to be implemented in the Robot Framework and therefore be able to run them without using said engine. These new libraries are also open source and can be used in the same way to create robots for KuFlow.
To facilitate the creation of robots with this technology, KuFlow has an open source SDK in Python that includes utilities such as a rest client for the KuFlow API (also available in Pypi).
UiPath
UiPath provides RPA software that allows you to automate repetitive digital tasks that are normally performed by people. Robots designed in UiPath are essentially composed of a set of activities controlled by logic and flow management statements.
In KuFlow, we have a set of activities that interact with the KuFlow API, making it easy for a UiPath robot to interact with KuFlow tasks and processes.
All available activities are hosted in the KuFlow organization within the UiPath marketplace. Likewise, the code for these activities is available in the open source SDKs provided by KuFlow.
Additionally, if necessary, we have an open source client for the Rest API in .Net available in NuGet.
UI.Vision
UI.Vision is an RPA framework that allows us to automate operations in web and desktop applications. One of its differentiating features is that it allows us to perform image and text recognition operations through automated visual tests using a user interface.
One of the disadvantages of these UI.Vision robots is that they have a limited way of executing code outside of their predefined catalog of instructions. That is, the ease and comfort of writing your own code for the robot is not very achieved. The main way is to invoke from the robot an executable or script that is available on the system where it is executed, and that contains the custom code. This makes a robot's communication with the KuFlow API also limited.
To overcome this limitation, a command line client has been developed that interacts with the KuFlow API. In this way, the necessary points of the robot code will use the external process invocation instruction, in this case our command line client, to achieve effective communication with KuFlow.
Choice of RPA technology
Once the decision has been made to use a robot to carry out work, it is time to decide what technology or framework to use. If you already have the robot code, that is, you are not going to start its development from scratch, use it. It is probably already written using some of these technologies, and if it is not, the changes to be made to integrate it into KuFlow will probably be minimal.
If you positively value solutions based on open source, Robocop and/or Robot Framework are a good choice. Likewise, perhaps their greatest strength is that they are tools developed in Python, so any library of this language can be used easily in robots. This opens up an almost limitless range of possibilities since the Python ecosystem is perhaps where the most free libraries and implementations can be found. Furthermore, if you need functionalities that require artificial intelligence, all the main tools on the market have libraries and developments in Python.
On the other hand, if your organization already has robots developed in UiPath then you would simply have to adapt them to communicate with the KuFlow API and integrate it into your processes. Once modified, all that remains is to deploy them in the appropriate manner depending on whether they are assisted or not assisted. We would act in a similar way with the UI.Vision robots.
Executions via Temporal.io
If the robot to be developed is an assisted robot, the maintenance to be performed is minimal and you can take advantage of all the power and versatility that KuFlow provides from the web application and the desktop app. Under the hood, these solutions are implemented using Temporal.io and taking advantage of all the possibilities it offers in terms of robustness and resilience to errors. In this type of robots, the code you must develop is only that of your own robot, forgetting about deployments and integrations. If the robot is unassisted, we recommend integrating its operation with a Temporal.io activity worker. Far from what it may seem, the code to implement part of your robot's code remains a simple and maintainable approach. The volume of code to be implemented is kept low and all the durable execution mechanisms provided by Temporal.io are available.
