By: Sreenivas Gudavalli
The term robotic process automation (RPA) is an evocative way to describe a technology that’s existed in various forms for decades. RPA combines several notions that have been tried separately in various technologies. Those of us who used Microsoft Excel in the early 2000s might remember recording our first macros to get the spreadsheet to do repetitive things. In the 1990s screen scraping technology was enjoying its peak, pixelating immutable mainframe green screens to find data that could then be shown to users through much more attractive client-server interfaces. Expert systems and rules engines have been attempted as early as the 80’s to structure repetitive tasks.
What does RPA mean for today?
Only recently, with new machine learning capabilities, these technologies have been re-combined to turn RPA into a mainstream capability as an AI-based human task automation tool, recording human-to-machine interactions to perform repetitive tasks across multiple applications.
RPA can automate human activities in all sorts of clerical work like customer service, HR tasks, and software quality assurance. While it may be obvious that RPA is an effective tool for digitization,what may not be evident to most leaders is that RPA can also be used to automate interfaces between systems. This is a simple, yet powerful concept. All it takes is adding a few more features into the RPA tech mix and, voila. We have another powerful tool in our digital transformation war chest.
Are we in the API economy yet?
Much has been said and written about application programming interfaces, or APIs, in recent years. APIs are simply user interfaces for software systems to interact with one another. It’s the new way of building today’s technology, stitching together disparate systems, services,and capabilities, whether in the cloud or our own software. But we’re not always starting from scratch, are we? It’s great to be building greenfield systems on top of a fresh stack of PaaS services, but most of us in the real world are constrained by legacy systems. Maybe not even our own legacy systems, but the legacy of creaking government IT back offices. This is where reality sets in.
When legacy systems abound and APIs are not available, RPA presents a compelling alternative solution. With a few modifications, RPA can be evolved as an advanced legacy software integration for the mid-to-long term. RPA can even enable non-intrusive automation of new functionality into legacy systems, like mainframes, where it’s just too cost-prohibitive and risky to build APIs.
Interfacing to external systems – applications in legal tech
While it’s more common for consumers to interact with “digitally native” companies these days, many industries that are critical to our long-standing institutions, like government and insurance, are still working to migrate their systems from analog to digital.
Legal organizations are no exception to this, and they face mounting back-office requirements with countless compliance checks along the way. Many have tried to digitize legal operations between law firms and the courts for filing suits, transferring documents and updating statuses. But every jurisdiction has its own court system. Even within one country, court technology varies from region to region and state to state. Some jurisdictions are adopting digital platforms to enable automated e-filing for law firms while others are still using manual processes and antiquated websites. For a firm operating across many jurisdictions, there can be an overwhelming number of interfaces to manage, all with different nuances and requirements.
This is where APIs and RPA can enable wholesale digital transformation for law firms. Law firms are often not the most tech-forward organizations. Many transaction systems at law firms are not conducive to API programming. Sometimes additional work is required to build custom interfaces for a case management system or Sharepoint-based document repositories. Once data integration with the firm’s systems and website is complete, the firm can then connect via our pre-built interfaces to the relevant court jurisdiction.
Maintaining fidelity of RPA-based interfaces
Lack of control over external systems is one of the biggest obstacles to the use of RPA as an interface method. Depending on how the RPA is set up, the position of a field or a button on a screen or changes in the navigation path can throw off the interface. Without a mechanism to actively manage system changes, RPA can fail as much as 4% of the time. For RPA to become a serious interface on par with an API, it’s necessary to take an industrialized maintenance approach.
One approach is to build a robust alerting system into the network of RPA interfaces. Any change detected in the e-court system is flagged and alerted to a central console. If the change causes an exception in the process, it’s tagged as urgent. The console is monitored by a trained maintenance staff around the clock, 24/7/365. For example, if you have 225 interactions spread over 60 e-court interfaces and 20%of them API based, we typically expect to see 8 alerts per month.
When a system change is detected, the Level 2 staff, trained in our RPA technology are available to immediately tackle and fix the problem. Our typical mean time to resolution (MTTR) is 3 hours, from initial alert to fully tested RPA adjustment.Using proactive alerting together with active support personnel turns the e-courts solution into a 99% fidelity platform. The remaining 1% of cases are completed manually, either by support staff or law firm paralegals. In this model, a good rule of thumb is to have a 1:17 ratio of support staff to RPA interfaces.
Because of the name “robotic” in the definition of RPA, and some of the problems maintaining interfaces, a lot of RPA mindshare is focused on clerical workforce processes. Using RPA as an alternative to API or EDI as a data exchange medium is a solid use case that deserves serious attention. A robust, cost-effective mechanism can be put in place to industrialize the RPA into a 100% fidelity automated interface. Using this technique as the last mile of legacy system interface enables a whole new level of digitization for otherwise legacy-bound organizations.
(The author is Senior Vice President & Chief Technology Officer, Provana and the views expressed in this article are his own)