Everyone knows what is it Liability insurance, we can offer a few ways how to protect the purchaser (the “insured”) from the risks of liabilities imposed by lawsuits and similar claims.
But what about insurers?
What if your insurance application or even important professional software solution is failed? How can you prevent this?
Yep, today our talk is about Insurance Reliability Engineering.
Let’s start with the term Reliability. It’s a key feature in insurance IT solution. Why?
Only image you use the mobile application, where Support 24/7 (Live Rep) is added. And something went wrong. Because of a mistake, how much time will you miss? How many clients, nerves and money?
Agree, it’s a simple example. You use stranger application and could complain or even write all insurance data on a piece of paper.
Supposing situation, in your CRM you do run into features that don’t always work in accordance with how you would want them to. Inability to update future effective quotes to reflect prior effective out of sequence transactions. And now you must recreate the quote and re-enter all data.
Is it too little?
The UX is often not intuitive. Slow response for large program policies is a frustration for users. And reports not working correctly and you miss data or even get incorrect counting. Say the truth I can continue this list of problems and will do this our next articles, but the main idea is that this is our reality.
How can we avoid this troubles? Reliability appears in this place. Only the use of reliable soft can help you to forget about main weaknesses.
So what exactly we mean when speak about reliability.
Reliability — ability of a software system to work as specified without failures. From the first sight, you may ask: is that so hard just to write a program without failures? Is it possible that a “software line of code” can possibly perform with failure?
The benefits of reliable software — is that you possible to develop a system with arbitrary complexity: any number of scenarios, any number of screens, forms, any number of integrations with third-party system. So the internal complexity of the software system is huge. Image a web of dependencies of many components. You touch one part — many neighbors are affected. Or imagine a tower — if there is a failure in the basement all higher levels of the tower suffer.
Imagine a customer journey in an insurance software system:
- Open the site.
- Search for available insurance options.
- Browse through search results.
- Create a quote.
- Pay for a quote.
There are many possible faults may occur during this journey:
- Database connection is lost — can’t open the site.
- Registration component is faulty — can’t pass registration and use the system.
- Search subsystem is broken — no search results.
- Database indexes are not built — no search results.
- Payment gateway is improperly configured — no payments at all.
And it is only a top of an iceberg!
Overall, business owners don’t care if it is a database problem, software problem, or third-party payment gateway problem — users are disappointed and lost, no profits from operation of the insurance system.
How Fortifier ensure software reliability in our projects?
First, we start from a project template. Fortifier completed tens of insurance projects for our customers all over the world. We maintain a solid domain knowledge: well-defined data structures, business processes, formulas. Also, we maintain a risk catalog: a list of bad things that can happen during the implementation or operation of the insurance system. That’s why our project plans work well for new customers — because the plans are proven by many other happy customers.
Second, our software architectures are peer-reviewed, and typical checklist includes the following points:
- Does the proposed architecture meet the customer needs?
- Does the proposed architecture meet the performance requirements?
- Does the proposed architecture include fault-tolerance measures for the most important parts of the system? (E.g. sign-in, sign-up, payments).
Third, we have a well-defined test plan. We know what to test in insurance systems, test plans and tests cases predefined already. So even small issues cannot escape our attention during test phase.
At the implementation (coding) stage we ensure reliability in following points:
- Our software developers deliver automatic component tests among with the source codes. Automatic component tests check for hundreds of rules automatically in a very short period of time (virtually in minutes). So, our developers see if something goes wrong very-very soon, without help of Quality Assurance/Quality Control people. Two benefits here:
- Software developers deliver only well-tested components.
- We reduce software development life-cycle by not passing the faulty components to QA/QC departments.
- Our developer-in-test engineers produce system-level automatic tests to make sure all components of the system are properly integrated and all user requirements are met.
- Besides automatic component and system tests, the system is checked by people manually to make sure all subjective issues are checked, too.
- The source codes are peer-reviewed, to make sure they meet our high level of standards.
Sometimes other companies stop here. But Fortifier goes even higher. We embed remote monitoring of key performance metrics, gather statistics remotely from a software system in operation. This statistic helps us understand if the working system performs well or not. E.g. we track the number of users who hit “Register” button and number of users who passed from the registration screen to the home page. In an ideal world, it must be 100%. If this number is significantly lower than 100%, e.g. 80% or even 0% — something bad happened and our attention is required: probably, a connection to the database is lost or registration component is broken.
As you can see, Fortifier ensures reliability on all levels:
- starting with software design and architecture
- software development
- software testing
- delivery and operations of the developed system