streamline your operations, improve productivity
thank you for choosing laiye rpa, the world’s leading robotic process automation (rpa) solution.
in this chapter, we will be introducing rpa and give a brief account of its history. familiarizing ourselves with the motivation and idea behind rpa will make understanding laiye rpa’s design choices much easier. if you already have experiences with rpa, then feel free to skip this chapter and start learning laiye rpa. otherwise, let’s dive right into rpa!
in this technology driven world, employees often encounter a lot of repetitive, tedious actions on
their computers such as downloading documents, recording invoices and audits, and checking emails.
it is not only easy to make simple mistakes while completing these tasks but also to feel bored and
devalued. for example, financial employees use online banking software to transfer money to their
clients. while making one transfer might not be troublesome, making hundreds or thousands of
transfers would drive anyone crazy. what’s worse, even one mistake can have terrible consequences.
just imagine if an employee accidentally enters an extra zero when specifying the transfer amount.
such things happen all the time.
the finance industry in particular suffers from this type of repetitive, tedious tasks, and in 2017, the
big four accounting firms (ey, pricewaterhousecoopers, deloitte, and kpmg) introduced the concept
of financial robots. these software bots make up a digital labor force that automates the manual work
people soon realized these software robots can be applied to much more than financial tasks, and
this idea quickly gained traction in other fields that have similar needs, including logistics, sales, and
hr. across the world, software robots are leading a new wave of automation that will free employees
for more productive and inspiring work, and from here, a new industry that manufactures software
robots emerges, known as robotic process automation (rpa).
while rpa is a recent development, the idea of automating software processes is not a new one. for example, it was over two decades ago when microsoft office introduced macros, which allow users to record their actions and run them as many times as they want.
figure 1: the “macro” function of office
however, rpa differs from early software process automation in its non-invasive approach to interact with existing systems: rpa does not need to modify the existing software to automate it. even if the software itself does not provide any support for automation, rpa can still automate tasks by simulating how humans interact with the software. imagine if an automation requires multiple software systems, possibly developed by different companies, to work together. traditionally, this would require developers to modify all these systems to implement a common interface, but by using rpa, no change needs to be made to these software systems. instead, rpa creates a software robot that simulates human actions, such as keyboard and mouse movements, to solve the challenge. this is one of the fundamental strengths of rpa.
in the last section, we have learned what rpa is and why we need them, but one question remains: how do we efficiently build software robots to automate tasks? let’s break down what needs to be done.
in order to implement rpa, we have to
analyze the existing workflows to sort out what aspects can be automated by software robots.
create the software robots and teach them how to read and operate all software systems used for the workflows.
deploy the created robots to the production environment, starting the robots, monitoring their status, and resolving any problems as they arise.
step 1 is done by experts of the industry. for example, to create a financial software robot, we need financial experts to analyze their day-to-day workflows. step 2 is done by it experts. for skilled developers, implementing a robot to automate human work is not difficult, especially using powerful programming languages like python. step 3 is done by regular employees, who only need to press a button to start the robot before they kick back, relax, and let the robot do the work. sounds great, right?
however, in practice, this is not the case. consider step 2. it experts are specialized in their own fields and often are not familiar with the business itself. the workflows analyzed by business experts might be difficult to understand for the it experts, and therefore they struggle to build the robots to behave as desired. moreover, in step 3, while regular employees can start the robots, they cannot resolve any problem that arises in production, since they don't understand how the robots work. all they can do is to ask the it experts for emergency support, which could bottleneck critical work from being done for days.
for example, as an it person, i always get a headache when i see financial terminologies like "operating assets" and "accounts receivable." likewise, the "threads" and "static methods" so familiar to me are probably confusing for most financial experts, not to mention regular employees.
the solution to these challenges is an rpa platform. an rpa platform decomposes software robots into simple, prepackaged functional components, which are like lego blocks that even business experts who are not familiar with it can assemble a powerful software robot out of. moreover, this decomposition allows regular employees to understand the basic principles and implementation of the robot, enabling them to carry out basic maintenance all on their own. these changes completely eliminate it experts from the equation by demystifying the software robots’ implementation black boxes, and thus the challenges are resolved.
in order to achieve the above concept, a general rpa platform should include the following three components:
development tools: powerful and easy-to-use tools to allow ordinary users to build and debug robots with minimal training;
operation tools: tools to allow ordinary users to deploy, run, and monitor software robots created by the development tools;
control center: centralized control tools to allow users to coordinate the deployment of
software robots on multiple computers, enabling users to distribute and schedule tasks amongst
groups of digital workers.
a good rpa platform is:
powerful, able to automate any task, no matter how complex, with a large toolbox of functional components,
simple, easily mastered by ordinary employees without the participation of it experts,
and fast, allowing ordinary employees to quickly implement their own robots in a convenient
rpa platforms have made great effort towards these indicators, but many fail to achieve satisfactory results. the main reason is that platforms often have to tradeoff between these indicators and struggle to balance all three. making an rpa platform powerful often sacrifices its simplicity, and a simple platform might not be fast enough. for example, some rpa platforms directly use the python programming language to implement rpa. while python, being a professional programming language, is certainly powerful enough, it is not easy for business experts and ordinary users to master. therefore, these rpa platforms ignore the two indicators--simple and fast--, and the result is naturally unsatisfactory.
laiye rpa is also an rpa platform. in order to balance these three key indicators of the rpa platform, laiye rpa has made a lot of efforts. some efforts can be found in the software interface, but some efforts may not be seen. for example, for some key design concepts of laiye rpa, our designers spent half a year to conduct in-depth research, iterated many rounds through discussion and experimentation, and finally came up with a relatively complete plan. therefore, we are confident to say that laiye rpa is a leading rpa platform, carefully developed to excel in and balance all three indicators.
as we have discussed earlier, in professional fields like finance, logistics, sales, and human resources, there are a large number of simple and repetitive software operations that turn valuable employees into human robots, but such problems also arose in video games. in order to maximize the time players spend in their games, many game designers intentionally created game mechanisms that force players to complete repetitive tasks over and over in order to progress in the game. these game mechanisms, just like the repetitive work tasks, make those who are forced to grind through them miserable.
as a result, people created software robots to automate repetitive tasks in video games, and the most famous one is quick macro. launched in 2001, quick macro only supported windows client games at the time, but related products, such as webpage quick macro, launched in 2009, and mobile quick macro, launched in 2013, added support for web games and android games. through such a set of product systems, the "quick macro" has swept across all the mainstream video games and accumulated valuable technology in the field of software automation.
the success of quick macro is not mainly because of its technical power, but because of its simple and easy-to-use design philosophy. quick macro itself is not a software robot, but rather a set of manufacturing tools for software robots. this set of tools needs to be easy enough for gamers who are not it experts to master. quick macro has made a great success at this point. today, tens of thousands of games can use it to create their own software robots and share them with other people. most of them are not proficient in it, and some have not even received higher education.
in a sense, quick macro, launched back in 2001, can be regarded as a pioneer of rpa. in fact, when the concept of rpa started to gaining traction in china in 2017, many related articles used quick macro as an example of rpa. although quick macro is designed specifically for video games, which are wildly different from software robots in finance or other fields, but because it is well-know and easy to understand, it is often used to explain the concept of rpa.
so, what is the production team of the quick macro doing now? have they made any progress in rpa? of course. they carefully analyzed the specific needs of rpa and innovated on the success of quick macro to create a product that not only takes advantage of the decade of experiences accumulated through quick macro, but also actively meets the needs of rpa. through years of hard work, they created a powerful, easy to use, and fast rpa platform. that's right, it is laiye rpa!
now, we finally understand why laiye rpa is able to stand out amongst all rpa platforms.
since they cater to different fields, quick macro and laiye rpa have some key differences in their basic design concepts, and in terms of the technology used, the differences are even more drastic:
quick macro is optimized for individual users, allowing users to customize the app’s user interface, set hotkeys, and use multi-thread operations, but all these functions are not needed and therefore removed in laiye rpa;
laiye rpa is optimized for enterprise users, supporting sap automation operations, visualized flowchart displays, and a distributed control center, which are not available in quick macro;
the main indicator of the quick macro is the high operation speed. because the game screen changes rapidly, it cannot keep up with the game if it is slow, but because the size of the software is small and the download bandwidth of individual users is limited, these indicators are not important for laiye rpa;
the main indicators of laiye rpa are good runtime stability and high error tolerance. every time it encounters an unexpected situation, it would rather stop running than blindly continue operating. in addition, each run of laiye rpa is logged. all these indicators are far beyond those of quick macro.
therefore, whether to use quick macro or laiye rpa depends on your specific needs: if it is for video games, then you should choose quick macro; if it is about rpa, then you should definitely use laiye rpa.
as mentioned before, a general rpa platform contains at least three components: development tools, operation tools, and control center.
laiye rpa is no exception. in laiye rpa, these three components correspond to our laiye creator, laiye worker, and laiye commander, shown in the following figure:
figure 2: three components of laiye rpa
if the operation scale is small, and only a few computers are needed, creator can create the processes, package them, and distribute them to each worker directly, and the whole procedure does not require commander. if the operation requires the coordination of a fleet of computers, it is easier for creator to upload the processes to commander first, and commander can handle distributing the processes to each worker and organize them to execute the processes in an orderly manner.
this article is a guide for laiye rpa developers, so its main content is about how to use laiye creator to create a software automation process, as well as some tips for best practice. there are some sections involving worker and commander, such as how to package and distribute a process to worker, how to upload a process to commander, and so on.
while reading this tutorial, it is recommended that you should go to laiye rpa's official website https://www.laiye.com/en/ to download and install a community version of laiye creator. it is permanently free, and you only need to log in online or activate it offline for unlimited use. if you have a little programming experience before and understand the concepts of variables and conditionals, then reading this article will be a breeze. if you don’t have that kind of experience, don’t worry; we have you covered. in the last chapter of this tutorial, we have attached an appendix, introducing some basic programming concepts that are important for understanding laiye rpa. read the appendix first before the following chapters if you need a refresher on programming fundamentals..
ready? let's start our laiye rpa journey!