(this article originally appeared in TheNewStack and was written by Jason Bloomberg )

Tricentis sponsored this post.

Automation has been around for centuries and business process automation has been part of organizations’ operations for decades. Robotic process automation, in contrast, has only been on the radar for a handful of years — and yet, it has taken the world of automation by storm.

Automation, of course, has been a reality since the Jacquard loom of the early 19th, when punchcards instructed machines on how to complete automated tasks. And just as its punchcard technology inspired Charles Babbage and later Herman Hollerith to “program” machines to perform more advanced operations, automation itself has evolved over the years as technology innovations hit the market.

We could even argue that the point of the first digital computers was to perform automation — albeit mostly of calculation tasks. As computing technology progressed, people gained the ability to hand-code automation — either by creating bespoke applications that automated otherwise manual processes or by creating applications that orchestrated interactions among other, older applications.

While such hand-coding can create any automation the business is likely to require, it is onerous, slow, and inflexible, as any change in requirements leads to another full software iteration.

Such limitations of traditional automation gave rise to robotic process automation (RPA). The basic idea behind RPA: get a piece of software to take over the mundane interactions necessary to complete a process that involves transferring information between multiple (otherwise siloed) applications.

No longer does a human have to click buttons, cut and paste values or type data into fields. Instead, the RPA bot will do all that for you. Just think of all the time and money that can be saved.

RPA is especially useful when the interactions are with older, legacy applications. Just one problem — if anything changes with the interface, the data, or any other aspect of the legacy app, then the RPA is likely to break.

Most RPA tools work at the user interface (UI) level, mimicking how the user clicks through processes, but interfaces evolve frequently, causing the automation to fail.

Automation at the application programming interface (API) level is more resilient than UI automation, but the older apps that are prime targets for RPA often lack APIs. There’s little choice but to interact with the UI, even though that approach leads to brittleness.

Another significant contributor to RPA’s brittleness: the fact that people must still hand-code the behavior of the bots. Simply screenscraping the UI doesn’t gather the business logic that drives the applications in question. Instead, screenscraping essentially identifies UI elements by their position on the screen. Change that position and the automation simply breaks.

Although RPA improves upon hand-coding a bespoke automation, most of today’s enterprise RPA platforms still require extensive programming to move beyond simple scenarios in order to create production-ready bots. In other words, RPA kicks the technical debt can down the road, as all the ills of hand-coded automation still plague the approach.

If only we could remove the need to hand-code altogether, we’d reach a new level of computing power and versatility. However, to get there, we need a better approach to implementing technology that supports the roles humans play when they automate the robotic automation tasks.

Model-Based Automation to the Rescue?

Many of today’s low-code and no-code tools provide visual modeling environments that create intermediate representations of application behavior in XML or other formats. The low-code platform, in turn, can directly interpret such representations as working applications in production — no hand-coding required.

This model-based approach that today’s low-code (as well as no-code) tools take delivers streamlined applications in less time than traditional hand-coding, often with higher quality as well.

The question for this article, however, is whether such a model-based approach will address the shortcomings of RPA. Based on Tricentis’ success with model-based automation — first in the test automation world, and now also for RPA — the outlook seems promising.

With Tricentis’ model-based automation, users simply scan the application’s UIs or APIs to create a business-readable automation model. In other words, it can automatically generate a model from an application’s interfaces.

Once users create these models, teams can combine and reuse Lego-like automation building blocks to create whatever automation they like. Furthermore, if the application changes, they can simply update the model, and software automatically propagates the changes to all impacted tests. Users work entirely with models, and the tool generates the tests, just as a low-code tool uses models to generate working applications.

Building upon its years of experience applying model-based techniques to test automation, Tricentis now offers a model-based RPA tool that resolves the brittleness issues of other RPA solutions — putting flexible, low-code models into the hands of the people responsible for building the automation.

Typical RPA tools cannot adapt to changes in UIs, data sources, or business processes. Leveraging model-based automation, Tricentis RPA eliminates this brittleness with resilient, “scriptless” bots.

Automating the Automations

Tricentis RPA automates bot creation and maintenance tasks, thus effectively automating the automation processes themselves.

However, it’s important to recognize that such automation of automation processes doesn’t eliminate the need for people. On the contrary: automating the automation empowers professionals to be more effective with their efforts, rather than reducing the need for human involvement in automation.

This empowerment benefit of automation, in fact, is one of the main reasons why automation-driven approaches to application development like low-code and DevOps make sense.

How can we expect automation to drive a cultural shift toward the greater collaboration that such trends represent? Not by eliminating people, but by empowering them.

What, then, do we do with RPA? Nobody wants an RPA project to amount to an expensive consulting engagement that leads to a brittle solution (except, perhaps, the consultants).

Instead, RPA vendors must rise to the challenge of automating the automation. They must replace the work of those throngs of consultants with automation capabilities that give their customers the ability to build and run sophisticated bots worthy of the name.

Read more from Jason Bloomberg — including how Tricentis RPA stacks up and the “Intellyx Take” on low-code RPA — in the complete report, “RPA Bots Too Brittle? Try Model-Based Low-Code.”