Automate Everything – an Experiment

Eliminating repetitive, boring activity is an excellent strategy for workforce retention. With proper automation software, significant “quick wins” are possible without investing a huge amount of capital.

There is good news on the labor market front: the unemployment rate has been falling. After the Covid-19 shock to the market, this is a welcome trend.

The above data is specific to the US labor market, but the situation is similar in other regions as well. In the media, the general labor shortage has been making headlines. The lack of qualified experts is now a daily complaint, and it is even more severe in highly specialized high technology areas like software engineering. Finding the right developers who specialize in more progressive fields of functional safety, cyber security, and artificial intelligence is even more difficult. The bargaining power of such experts has steeply increased. The “Great Resignation” strongly correlates with this trend.

Organizations increasingly invest in talent acquisition and talent retention. Job descriptions are being rewritten and job definitions become updated to attract talent. At the same time, tedious, repetitive, intellectually uninspiring, recurring activities such as compiling management reports or crunching spreadsheet data are increasingly unpopular among tech experts. Asking computer scientists to fill out management spreadsheets might seem like a juxtaposition.

Nonetheless, some repetitive activities are crucial in tech organizations and cannot be neglected. For instance, calculating quality KPIs are indispensable in safety projects. Unfortunately, functional safety experts are precisely the ones who are becoming exceedingly scarce. Hence, every check box on a quality spreadsheet report can be very costly. The saying “Time is money” may be a truism in our modern society, but the notion lead to demotivating, repetitive activities, adding insult to injury.

For those reasons, highly qualified experts must be relieved from repetitive work whenever possible, allowing them to focus on more complex tasks. At the same time, however, performing even uninspiring activities such as filling out quality reports based on existing data cannot be easily passed on to a less technologically trained person because of the complex context in which such spreadsheets are filled out. Thus, although tedious and repetitive, such work still must be performed by an expert because even small mistakes in such a safety-relevant report could result in unpredictable legal risks. Therefore, hiring a less qualified person and training them to perform such work requires additional effort, and the training is typically done by the same person who should instead focus on solving more specialized, complex tasks.

Robotic Process Automation (RPA)

In principle, automating repetitive tasks seems simple. For instance, recording a macro in a spreadsheet is pretty straightforward. However, it quickly becomes a challenge when the tasks become more complex, and debugging such macros is cumbersome because spreadsheet scripting languages are often illogical and error-prone. That’s where intelligent automation software can help.

RPA (Robotic Process Automation) is a fast-growing market that is not showing any sign of slowing down.

There are numerous RPA solutions on the market, among which UiPath is a market leader.

RPA solutions bear the promise of finally resolving the Gordian Knot of automating complex tasks with little effort. However, while vendors advertise ease of use and the high effectiveness of their software, I have remained skeptical and decided to evaluate it first before recommending it to any of our clients.

Constructing and Evaluating an RPA Robot

The following questions inspired our evaluation approach:

• What skill level is required for an employee who has the task of automating a process?
• What is the effort of automating a process?
• What is the resulting process runtime efficiency as compared to the originally manual process?

Since RPA tools are still a young industry, we must assume that there are not many professional RPA developers in the market. Therefore, it was interesting to see how well an inexperienced person with the right motivation but little previous involvement in the field can perform the task of developing and running RPA solutions.

Step 1: Hire a developer

For this job, I hired a middle-school student (14 years old) to evaluate and automate a business process based on the above mission statement. The time given was one day to deliver a working, automated process.

Step 2: Task description

The mission statement summarized by the young developer himself was as follows:

“The goal was to see whether or not creating a program which automatically completes Excel quality assurance tables with a project ID and name is an effective replacement for manually filling in the data.”

I gave the student the following task list:

• Download the demonstration version of the UiPath software directly from the vendor.
• Find training material from the vendor or on YouTube, learn what it does, and understand how it works.
• Using 15 QA (quality assurance) checklist templates as an input, create a complete set of filled-out QA checklists with correct metadata (project ID, project name, etc.) so that those checklists can be immediately used for QA reviews in a real-world automotive project.
• Record the time consumed by all activities and summarize the results.

Step 3: Develop the RPA solution, test it, and summarize the results

In the young developer’s own words:

“This task was to be done with the RPA software “UiPath” (Version 2021.10.4), of which I had no prior knowledge. [I was wondering about] the learning curve of getting to know UiPath well enough to use it effectively. After developing the code, I would time first the program execution time, then myself doing the same thing manually, both with 15 different pre-filled spreadsheets.“

The Results

In the developers’ own words:

“The entire task took about nine hours from start to finish. That is, from learning the software to creating the program, running the tests, and documenting the results.

After finishing the UiPath script, I ran the tests:

1. Manually: finding, opening, and filling out all forms by hand took 10 minutes and 38 seconds, using mainly copy/paste operations to set the correct values in each sheet.
2. Automated: Running the automated script took 15 seconds and the script put all the relevant data into the spreadsheets.

Lastly, I then summarized the results.”

Discussion

At the end of the day, we have discussed the results. The task turned out to be both challenging and exciting. It was not an overly demanding task, however. We also discussed the level of complexity and the effort needed to automate the scripts further and add more functionality to the automation, such as retrieving data across directories and databases to fill out the spreadsheets. We recognized that additional skills for such automation would be needed. For instance, RDBMS and web design knowledge must be acquired first.

I thought the learning curve was quite steep and the initial results are instantly visible. That is good news since it helps the developers remain motivated. Also, the UiPath community is quite strong, so finding solutions to various problems and getting help was easy.

It is noteworthy that my young student tackled the task without any training, preparation, or experience in the field of software development. However, based on my experience in that field, I must assume that a well-trained, seasoned developer with year-long expertise could deliver results many magnitudes faster.

While the ease of use of UiPath was a pleasant surprise, running the automated tests was not less insightful. The automated task took 15 seconds, while the manual counterpart consumed about 10 minutes of manual work, suggesting a  forty-fold efficiency increase when using an RPA solution.

Such comparison is naturally oversimplified, and further aspects that usually affect task efficiency should be considered. For instance, automating a task often requires a deeper understanding of the matter, such as Automotive SPICE in our case. It can mean that not only automation but also running such automated tasks might require technical knowledge. For example, if there is a difference in a project regarding the required functional safety level in an automotive development project, the user running the scripts would have to make an educated decision regarding the different QA checklist content for each ASIL level (QM/A/B/C or D).

In addition, automated tasks are often needed sporadically rather than continuously. That further reduces the average efficiency gain factor.

All of the above concerns do not diminish the potential of the RPA approach. For example, a PMO (Project Management Office) employing five PMO professionals supporting dozens of projects and frequently performing project audits can save several FTE (Full Time Equivalent) per year by automating repetitive audit tasks. Even if just one person can be spared thanks to the process automation–which in the light of our experiment seems highly likely–the ROE of using an RPA solution is mouth-watering to any CEO.

In other areas (such as manufacturing), customer first-level support, automation of development tasks such as code baselining, complex merging, traceability coverage calculation, and many more, high-efficiency gains thanks to RPA are guaranteed.

Conclusion

We are currently experiencing an extreme talent shortage in multiple industries. In many cases, process automation offers a solution to this problem. Even if the economic cycle changes and acquiring and retaining highly skilled workers is likely to become easier, we have proof that RPA works and can deliver further efficiency gains. Boring, repetitive tasks can be eliminated, and highly skilled personnel can finally do something more productive. As a result, I predict that RPA will become an internal part of many businesses for decades.

---

Let’s start a conversation on LinkedIn or X.com (formerly Twitter).