Porting and optimization of B2C claims applications to modern architectures and technologies
The initial situation:
The client was a leading German insurance company that had both a traditional brand and an online-only subsidiary. Both brands offered their customers the option of reporting claims online.
However, the existing solution was technologically and functionally outdated. It was based on a monolithic approach that only provided a long form that only sent a structured email to the claim handlers at the end. This led to a long process time, a poor conversion rate and a high workload for the clerks due to a lack of automation.
The assignment
The insurance company tasked FIDA with completely modernizing the B2C claims applications and creating a solution that would automate the claims reporting process, provide a better user experience and reduce the internal processing burden.
Our objective
The main goal of the project was to create a new, modern application that would make the claims reporting process as simple and efficient as possible for customers. Modern UX/UI principles were to be applied in order to maximize user-friendliness and significantly increase the conversion rate.
The new application should also be easy to use on all devices - from desktops and tablets to smartphones. At the same time, it was to largely automate the claims reporting process through deeper integration into the insurance company's backend systems and enable direct integration into the claims processing system. The aim was to process claims as far as possible "in the dark", i.e. without manual intervention by claims handlers.
In addition, useful additional functions were to be provided over and above the pure reporting process in order to make the process more convenient for customers and reduce the burden on internal processes. The architecture of the application needed to be modular and future-proof, with a focus on standardized interfaces and a cloud-enabled infrastructure.
Our solution
The claims reporting portal was completely redesigned and implemented on modern technologies and architectures. The entire process was divided into several single-page applications (SPAs), which were implemented as microfrontends. Microfrontends are an architecture for web applications in which the user interface is divided into smaller, independent modules, each of which can be developed, tested and deployed by different teams. These modules or "microfrontends" work together to form a complete user interface that appears to the user as a cohesive experience. The microfrontends of our application were designed on a line of business and product-specific basis in order to optimally map the individual requirements of different insurance products such as motor vehicles, residential buildings or protection insurance.
The application is accessed via a decision tree that guides users through the process with simple questions and automatically redirects them to the appropriate interface. This reduces complexity and ensures a personalized user experience. Dynamic forms, clear instructions and interactive elements ensure that reporting a claim can be completed quickly and intuitively. Additional functions include the option of requesting a breakdown service directly, selecting a partner garage or receiving an automatic payout for minor damage.
The porting and optimization of the B2C claims applications led to significant improvements both for customers and for the insurance company's internal processes. The new applications are intuitive, fast and usable on all devices, which considerably improved the user experience and significantly increased the conversion rate.
A look at the details: What was important?
When implementing the new B2C claims applications, a particular focus was placed on user-friendliness, technical architecture and automation.
The front end was developed with Angular and uses modern technologies such as RxJS and ngrx for state management. By using nx as a monorepo project tool and web components, the in-house style component library could be seamlessly integrated. The design of the microfrontends as independent SPAs also allowed for modular and flexible further development.
The backend-for-frontend services were implemented with Quarkus and NodeJS and act as a central communication interface between the frontend and the internal backend systems. This architecture ensures a clear separation of responsibilities and better maintainability.
Deploying the entire solution in the AWS cloud not only ensured high availability and scalability, but also reduced the load on the in-house hardware. By using IaC tools such as Terraform, the cloud environments could be planned and provided efficiently.
Security was another key aspect of the project. The integration of the insurance company's existing on-premise OAuth2 process based on ForgeRock ensured that authentication and authorization met the highest security requirements. Sensitive data is encrypted both during transmission and storage. In addition, extensive security checks, including PEN tests, were carried out to identify and eliminate potential vulnerabilities.
To ensure the quality of the solution, a comprehensive test framework based on Jest and Cypress (frontend) and JUnit (backend-for-frontend) was implemented. The tests were integrated into the continuous integration pipeline, which was implemented using Jenkins. In addition, automated checks for codestyles (ESLint, Sonarqube) and security vulnerabilities (NexusIQ) were carried out.
