Is RPA the future of test automation?
IT organizations will use test automation, RPA and low-code development tools to create, assess and automate complex processes in the near future.
Software testing skills can translate to other areas of IT, like application design, analysis and programming -- even intelligent automation. Emerging technologies, such as robotic process automation, look a lot like modern software testing.
Robotic process automation (RPA) performs repetitive operations repeatably, on demand. However, much of what can be automated already is -- within the application itself. The opportunity to improve a process lies with automating the integration points: the handoffs between teams and other systems. In this paradigm, RPA has a lot of traits that resemble test automation, especially those tests that mimic real user actions.
The future of test automation and test automation engineers might lie in this field of humanlike actions and interconnections between systems. End-to-end testing simulates a customer's expected actions in a piece of software. One user activity could be a complex process that relies on many components of the software. Record-and-playback tools provide test automation for sequences like this, without programming. The tester runs through a user action, and the tool records and copies the action. Set this sequence to run repeatedly, and it creates a synthetic testing program. Some companies use synthetic transactions, particularly read-only ones, in production. Synthetic testing enables the company to monitor real user experience, not just check functionality in isolation.
That effort to create a repeatable, automated end-to-end interaction with a system, it turns out, is remarkably similar to RPA. RPA is the logical future of test automation technologies. Let's examine some examples of test automation and RPA to see how they overlap and differ, as well as the skills required to work in these automation fields. And we'll see how another software development trend, low-code, could enable a wave of RPA implementation.
What RPA brings to application automation
Robotic process automation's appeal is how it turns complex, multistep and multisystem tasks into repeatable scripted processes.
Many of us are familiar with keyboard macros: automated sequences to perform the same typing and cursor moves repeatably, on demand. Macros mimic human actions. RPA takes that idea to the next level; it sticks some values in variables and reuses them to automate actions. This functionality is similar to data-driven test automation and synthetic transactions.
RPA can automate many functions performed by an accounts receivable clerk, for example. A major part of the job is to check the accounting system and email people when their accounts are past due. This manual process takes up the clerk's time and has potential for error if he misses a late account or forgets to send an email once drafted. An RPA system can send those same emails automatically, based on a trigger set off by the account's balance and bills against it. In this example, testers can create their own system to list past-due accounts, compare values and send emails, which demonstrates the likeness of test automation and RPA skills.
In another example, RPA can improve help desk and support systems. When combined with AI, RPA can monitor incoming tickets and what operators do in response, so that the system can guess the right change to fix a problem. While the potential of AI outweighs its current applicability, RPA's simple if-this-then-that integrations are ripe for combination with discovered patterns in data.
Low-code development is a twist on RPA
Where RPA and test automation both simulate the actions of a person and tie together pieces of a system, low-code development platforms produce a product for people and other systems to use.
Low-code platforms are essentially visually specified databases, to create web and mobile applications. These applications usually require a little field validation and data logic to get apps up and running. They provide process automation to generate and link together templates for common business functions.
For example, if a company wants to start a user conference, it needs app functions for the conference: the schedule, talk details, speaker pages, venue information and registration page. Those elements are so common that templates for them exist, and the company simply fills in the blanks to quickly create their own conference website and mobile app. Users follow prescribed paths through the application to sign up, book a hotel and select their session schedule. Because the low-code tool created the integrations from one component to the next, it eliminates process fragility, incompatibilities and complexity at these handoffs.
Better together
Test automation is a niche within software QA, and its future is not certain. Some organizations are eliminating end-to-end system test tooling, while others are moving automation work from testers to programmers. While RPA and low-code use are on the rise, they're far from established technologies. It might be possible to get a job that focuses on one of those three tasks, but it is hard to translate those skills to the next job.
To really unleash the capabilities inherent in these trends, combine test automation, RPA and low-code with a focus on business ROI. For example, if you work with test automation in QA, find areas where you can apply it in production. Once you get synthetic transactions up and running, you've demonstrated a form of RPA completing tasks in production. Study the internal working of the company to discover where else RPA should (and should not) deploy. Inefficient, tedious and troublesome tasks are ripe for intelligent automation that's made to handle multiple transactions and handoffs.
The next step from test automation and RPA is to build custom software to address business concerns and problem areas. Low-code tools provide the technology to create these applications without a huge time and resource investment from IT. What all three trends have in common is a way to think in abstractions, as well as create a user interface. Where test tools demonstrate that a system can work as designed, RPA drives changes to systems, and low-code creates the systems themselves.
