Robotic Process Automation for a top Swiss insurance
Estimated read time: 15 min
What you’ll learn: How RPA can bring agility to Standard Software owners and see a concrete example from one of our client cases.
Ideal profile(s): Application owner, Business Engineer, Automation specialist, Tester
Author: Dorian Cransac (exense GmbH)
Summary
This case study revolves around a Robotic Process Automation (RPA) implementation at one of our clients, a large insurance company located in Switzerland. We will see how RPA enabled our client to meet critical business requirements in a high-pressure environment and eventually gained a competitive advantage despite using a standard software solution.
Motivations behind RPA
There are many reasons which can lead a company to use RPA, here’s a short list of the ones we’ve witnessed over the years as automation specialists:
| No need to wait for the next release: with GUI-based scripting, companies move quickly by automating scenarios which would otherwise have taken years to implement in the system or would never have been delivered at all | Since the code of the application is not modified, there is little to no additional risk to run RPA against the target application. RPA does nothing which human users could not have done. | With versatile scripting libraries, it is possible to interact with heterogeneous systems and synchronize data using an RPA-enabled orchestrator |
| RPA teams can work independently from the software vendor and since scripting is much easier and lighter than traditional development processes, a lot of money can be saved | Assuming you’re using a so-called “standard solution”, building services relying on RPA can enable features which your competition won’t be able to if they stick to the standard version of their software | By definition, RPA is driven by business users. By removing barriers between business and IT, RPA increases productivity and ensures that automation services match business requirements |
In other words, while it is not necessarily intended as a long term solution to every new automation need, RPA can be seen as the ultimate agile approach for legacy IT environments or for companies relying heavily on a standard software solution such as an ERP. In this case study, we will take a look at how we’ve been able to help a client stuck in a slow-paced release cycles and enabled new automated workflows in their system.
Challenges
Companies relying heavily on software to deliver mission-critical services are faced with tough strategic choices these days. If you’re working for an insurance or a bank, there’s a good chance that your company quit building their own in-house software and decided to move to a “Standard Software Solution” instead. Typically, companies would only use standard software for tasks associated with no particular competitive advantage and posing no sensitivity issue from a business perspective. Let’s say, if you needed to work with spreadsheets, you would turn to existing standard solutions such as Libre Office or Microsoft Excel. No need to reinvent the wheel.
When it comes to mission-critical software however, there is a case to be made for in-house development. It’s a good way to protect your business secrets from your competition, including from your own software provider(s). It is not rare to see a software provider move into a market segment previously owned by their own customers. For instance, you can take a look at the infamous Google Search moves in recent years, putting many companies such as flight search engines out of business after having earned tons of money from them via ads and other ranking-related products.
Assuming you’re dealing with a loyal and faithful provider, there are still other kinds of risks you’ll be facing after adopting their standard software. For one thing, you’re not in control of software releases anymore: your influence regarding the upcoming content is limited or inexistent, and you can’t decide at which pace updates are rolled out. Keep in mind that standard solution providers are likely to think about their own interest first, not necessarily yours. We’ve seen clients placed under high pressure for not migrating fast enough or sometimes clients stuck in the opposite situation: they’re in desperate need of a new set of functionality, which would always be delayed or sometimes simply denied. What do you do then?
Even if you’re one of the lucky ones and you’re satisfied with your solution now, what kind of guarantee do you have that your competition will catch up in a few years, since they’ll benefit from the exact same capabilities through the same standard solution they’ve purchased?
These are some serious challenges that need to be taken in account early on, preferably before making any big move. This is not a rant against standard software solutions however. These systems make absolute sense and, to be fair, they do allow their users to differentiate themselves from one another through customization (or “parameterization”). Our experience just indicates that users rarely get the smooth ride they were initially promised. And this is where RPA comes in.
Client context
At the time of this story, a recent and sudden change to laws governing health insurance options for France-Switzerland border workers lead to a major impact on the insurance system. Tens of thousands of customer’s data needed to be migrated or inserted into our client’s system within a few weeks.
Our client quickly realized that this task could never be done by hand, at least not fast enough and not without losing many customers. They turned to their software vendor for help to see if a batch implementation could have been delivered in time but due to the rigidity and slow-paced nature of development and acceptance processes, our client decided to turn to RPA (and step, our automation platform) instead.
Technical stack
Although the RPA principles described in this case study apply to any software stack, for those interested, we will briefly describe the software and technical architecture at hand.
Syrius, a standard application
The standard application subject to automation at our client was called Syrius. It is a comprehensive solution for insurances and it is particularly popular in Switzerland.
Architecture overview
Syrius a distributed application comprising of a data layer, business tier, presentation tier and a Java client (with two implementations in Swing and FX).
A key requirement in order to make RPA possible given this architecture would be to provide a stable solution for simulating user events inside the Java client, passing dynamic inputs to each execution and then scaling these executions.
Data inputs
The data serving as an input of the information (such as customer information, insurance plan, etc) was received in the form of Excel files. One of the wishes of the client was to make sure that business analysis would be able to work directly with excel spreadsheets and if possible, drop them into a folder as part of the preparation of the automated scenario’s execution.
Solution
In this section, we will first look at an overview of the technical solution retained to automate workflows based on the Java client. Then, we will identify key features that resulted in substantial benefits for the client. We will also see how these benefits relate to the initial motivation factors for RPA which we discussed at the beginning of this article.
Technical implementation
The chosen technical stack to design and execute the automated workflows comprised of Oryon, an out-of-the-box solution for Swing/FX automation and step, our state-of-the-art automation platform which can be used for the massively concurrent execution of Oryon scripts via a plugin.
Oryon, Automation for Syrius
Our scripting solution for Java clients, called Oryon features a driver capable of recording and manipulating objects in Java clients and comes with a development studio (IDE) for editing and intuitive script replay. In this particular case, our client used our custom plugin for Syrius, which came out-of-the-box with Oryon. This plugin allows for even easier recording and improved stability, as it is aware of information on the specific implementation of the Syrius client.
Orchestration and scalability
In addition to Oryon, step was retained as an orchestrator and for the parallel execution of the data migration scenarios.
step is a comprehensive automation platform featuring a controller-agent architecture allowing for high scalability. It also comes with the key advantage of centralized archiving and monitoring. This means that our client would be able to make sure in real time that each migration was successful and go back through the execution history to identify and investigate errors.
The figure above will give you an idea of what execution results would look like in step. Each execution would lead to reports featuring a status, potential errors, attachments, screenshots and all the necessary information to diagnose issues and find the involved business objects in the system if needed.
With step’s agent grid, executions were scaled up to thousands of cases per minute and could have been scaled even higher if more infrastructure had been provisioned, but the throughput reached was deemed enough to solve our client’s problem.
The new automated workflow
The following diagram summarizes the new workflow for users involved in the RPA campaign:
Here’s a step-by-step description of how our users work with the RPA platform:
- The first step is the click & play recording of the scenario using the Java client along with a deployed Oryon agent, this step will produce a script as an output
- Once the script is ready, our user needs to prepare the data which needs to be mutated or inserted. This will be done using Excel spreadsheets. When the data is ready, the file is dropped into a shared folder and will be picked up by the automation orchestrator once the scenario is launched.
- The script is deployed onto the platform via drag & drop. The scenario can now be launched.
- Execution ensues, script executions are distributed across a network of agents and scaled out. Our user can now focus on browsing execution results and potential errors. Performance metrics are also available.
Benefits for the client
Let’s review the RPA benefits table and see how the proposed solution kept the original promises.
| The installation, scripting and first execution of a basic scenario took less than 3 days. Commissioning VMs to scale the step agents and preparing of the data to be migrated took longer, but this was dependant from third-party teams | The import of the customer data was performed successfully without exposing the target system to new potential bugs. | Although most of the changes needed to be made in a single system, most of the data came in in the form of excel spreadsheets which were used “out-of-the-box” as a source of data in step |
| From the perspective of human effort, the RPA campaign saved a large number of man-hours. From a business perspective, the success of the campaign made it possible to meet critical deadlines | In subsequent campaigns, and using the same chanel to import data, our client was able to provide its customers with new services that competitors could not offer | With easy recording, a simple web interface for result analysis and Excel spreadsheets as a source of data, business analysts were able to use the solution directly, reducing the need for engineers to support them |
Demo
We’ve recorded a couple of short videos showcasing the recording and execution of Oryon scripts using the Syrius FX client, so you can get an idea of what the automation looked like in the end.
Here’s the recording part:
And here is the variabilization of the person’s first name and the replay (i.e execution of the script):
Conclusions
Not only was our client able to solve the sudden problem they were faced with and migrate all of the customer data in time, but they’ve since kept building new RPA routines on top of the existing stack and use it continuously to offer new services to their own customers. RPA had started as a technical solution to an automation problem but ended up as a key competitive advantage for this insurance. They’ve launched several campaigns with features relying purely on step and Oryon.
In the long run, it is likely that the legacy software provider will adjust and add some or all of these services to their catalog, but in the meantime RPA has proven to be a great way to react quickly and efficiently to sudden changes in the business.