-
|
|
|
|
Table of Contents:
- The market demands agility and innovation
- Insurers are playing catch-up
- The insurance citizen developer
- What is low code development?
- The difference between "no code" and "low code"
- The top 3 benefits of low code
- The top features of low-code development platforms
- Keep it real
- Enterprise vs. use-case vs. vertical-insurance platforms
- Are there any challenges to adopting low-code platforms?
- Lessons from an integration project: the future lies in integrating horizontal and insurance low code platforms
- Lessons from an integration project: the core system can be the most significant barrier to implementing a true low-code paradigm
- Top challenges for insurance software
- An end-to-end low code approach to IT is needed
- AdInsure, a modern digital insurance platform designed around the no-code/low-code paradigm
- 15 top features that make AdInsure a no-code/low-code insurance platform
The market demands agility and innovation
The insurance industry has never been synonymous with agility, but times are changing and consumers today expect an immediate response. They demand digital experiences whenever and wherever they want them. They require more suitable risk coverage. However, a study by Forrester has found that despite the constant emergence of new risks, only 50% of them are covered by suitable insurance offerings.
The result is a growing IT backlog.
In the post-COVID digital world, the role of technology is not only to make the process more efficient but also to enable Innovation.
In an era when everything seems to be changing at breakneck speed, traditional approaches to operating technology may hurt insurers' bottom lines. According to Gartner, 65% of all enterprise applications will be built using low-code technologies by 2024.
Insurers are playing catch-up
While the problem of conflicting priorities between keeping the systems running and innovating is nothing new for IT, it continues to grow. Market success depends on highly skilled technologists, yet the global IT sector suffers from an unprecedented skill shortage. Rather than driving Innovation and change, insurers are playing catch-up.
Gartner's research suggests that new products and improved operational agility were the top priorities for insurance IT in 2021.
Insurers have difficulty keeping up, especially when operating with legacy systems and core systems that do not support a high level of self-sufficiency. According to Gartner (NOTE: "Why Insurance Product Leaders Must Reevaluate Their System Configuration Capabilities" available only to Gartner clients), insurers strive to achieve a level of self-sufficiency that would allow them to launch new products on their own. However, software solutions (such as core systems and low-code/no-code platforms) claiming to be fit for purpose are often more hype than reality.
The insurance citizen developer
To bridge these gaps, many insurers have started exploring low-code platforms to strengthen their operational capabilities.
The goal is twofold. To increase the efficiency of software professionals and ¸empower business and business technology users (citizen developers) to create or modify business applications (while remaining under IT governance). This trend is also seen by analysts and consulting companies evaluating low-code platform use cases to advise the insurers on the direction and trends. Here are two example reports by Celent and Novarica.
The citizen developer approach allows IT to hand off some critical tasks to the business side. A cleared backlog allows them to shift their focus to Innovation.
Furthermore, the approach allows business users to become active self-driven implementers (rather than adding to the already vast IT backlog). Low code empowers them to implement what the business needs instead of waiting for IT.
Our experience confirms that insurers can rely more on business users in areas traditionally associated with IT. With the right tools, business users can take on a large part of insurance product and process design independently and without active support from IT.
Our clients' business users also use AdInsure Studio. This confirms that insurers can empower business users with easy-to-use tools in areas that traditionally require lots of IT effort. Insurance product design and configuration and premium testing is an example of such an area that can be performed within AdInsure Studio by business users independently and without IT's active support.
What is low code development?
The low-code paradigm is a software development methodology that requires minimal coding. As such, it gained popularity among developers who wanted to get things done quickly. It then moved from developers with technical knowledge to non-developers. The shortage of developers makes it even more important and strategic today.
Modern low code platforms enable both professionals and non-professionals to create Software tailored to their organizations' specific requirements. Low-code platforms come with tools that use drag-and-drop interfaces instead of programming languages so non-professional developers can build business apps with as little coding as possible.
The difference between "no code" and "low code"
According to Gartner, there is no such thing as "no-code." They are convinced that "no code" is more of a marketing term that implies the tools are for non-professional developers. On the other hand, low code suggests using a scripting language in addition to all the no-code platform capabilities outlined below. Because of this, this article will not distinguish between low-code and no-code platforms.
The top 3 benefits of low code
For a platform to qualify as low code, it must deliver the promised benefits of the low code paradigm. Here are some of the benefits of using low code:
- It saves time and money - there is less coding needed to build an app, a process or a product.
- It accelerates the time to market - again, you can quickly create your app or process without writing any code.
- It empowers citizen developers - professional programmers are not the only ones who can develop software solutions for your business.
A low-code insurance platform (or a low-code approach to IT) is meant to significantly reduce time to market for insurance-specific solutions such as configuration and distribution of new insurance products, modifications of agent portals, and the underwriter's workbench, customer quoting tools, claims service portals, and more.
The top features of low-code development platforms
Low-code platforms typically include the following capabilities/features:
- Visual interface-based tools with simple logic and drag-and-drop support allow users with no formal coding knowledge (aka citizen developers) to create applications.
- Data integration for connecting data from multiple sources into a single location.
- Embedded databases.
- An API that enables developers to integrate with other systems like CRM, ERP, etc.
- Security features to protect sensitive information.
- Reporting and analytics tools to generate reports and measure performance.
- Deployment features for releasing new versions of the application.
- Versioning for tracking changes made to the app over time.
Keep it real
As nicely put by Kevin Crawford from Endava, you have to keep it real.
Low Code tool providers will claim that applications can be built within days or even hours. This may be true for something that can be demonstrated as a proof of concept. However, if you want to build something to be used within a production business application, then the hours and days will more realistically be weeks and months. This will certainly be the case if the deliverables are externally facing, have integration points, and include other elements such as document production.
There seem to have been several attempts to measure the possible impact and benefits of the low code approach. They suggest some impressive numbers, such as the 5x to 7x productivity improvement. That's an impressive number.
Undoubtedly, low-code development is a reality today, and it can help insurers move beyond legacy systems and move faster without writing code. However, caution is required, especially when developing industry-specific solutions.
Enterprise vs. use-case vs. vertical-insurance platforms
Insurers can choose from several different kinds of low-code or no-code platforms. One category is the enterprise platforms well covered by leading analysts like Gartner. These include Microsoft Power Apps, Appian, Pega (many are business process management platforms).
The second category comprises use-case based platforms that fall into several categories on their own, as nicely outlined by the VentureBeat article:
- Web site low code platforms.
- Database low code platforms.
- Automated integration low-code/no-code platforms.
- Mobile application development.
- Customer experience platforms
And then, there are the platforms that support industry-specific context like our AdInsure insurance platform.
AdInsure is a low-code platform that ticks all the boxes of what low code is. The low-code and the citizen developer paradigm are fully aligned with how we approached the design of our insurance platform. Our goal was to enable business teams to quickly prototype new products and business models as well as provide operations with the means to implement changes at a fraction of the cost and time.
Are there any challenges to adopting low-code platforms?
Low code/no code requires a change in culture, which we know is not easy, especially in siloed organizations such as insurance carriers. Additionally, it requires learning and training – the tools and platforms are still not trivial to use, and developing the necessary level of expertise can take time. Organizations must get real and go into any project with this understanding.
However, integrating these platforms into existing insurance IT architectures and processes will be the biggest challenge. Insurers will have to combine different platforms covering different use cases to maximize the benefits. There is no one-size-fits-all, and we learned this during our low-code research.
Low code and no code are not the silver bullet for insurers. While low code may solve some issues, it is more about a general approach to IT. Even without low-code tools, leading insurers can already significantly cut costs and accelerate time to market. It is more about balancing a modern ecosystem-based digital architecture centered around a digital and open insurance platform around which low-code applications are built and partner ecosystems integrated.
Lessons from an integration project: the future lies in integrating horizontal and insurance low code platforms
One of the low-code platform insurance examples we could find early was the face to quote use-case by Zurich that Mendix (an enterprise low-code application platform) was marketing. FaceQuote is a custom app that provides the client with a life product quote based on a selfie. As we are interested in testing low code concepts ourselves, we have decided to test drive and develop a prototype.
During the process, we identified the possibly biggest obstacle to the full potential of the low-code approach- the non-low-code nature of legacy platforms. Suppose the application you are building needs to integrate with other business IT systems, which is typical for the insurance industry. When these systems themselves require change, it helps greatly if they are low-code compliant, which turns the whole change process into a low-code project.
Here is what it took us to implement this kind of solution:
- Design and implement the client-facing application. This part was entirely completed using a low-code enterprise platform. There was a learning curve, but our Intern (under the supervision of a senior developer) completed the work without significant hiccups.
- Integrate the application with an insurance product rating engine. To calculate the Quote premium, we integrated the application with AdInsure. AdInsure standard life products include premium calculation and APIs, making the integration straightforward.
- Integrate the application with an insurance sales (or PAS) system. An alternative to integrating a "premium engine" would be to code the premium calculation on the application side (well, this is one of the tests we will do next to compare this approach). A more complex part of the solution is integrating the Quote seamlessly into an existing sales process usually supported by the policy administration system. This step was also straightforward as we integrated the Quote with the AdInsures Sales module, immediately making the Quote visible to the sales and underwriting team.
Lessons from an integration project: the core system can be the most significant barrier to implementing a true low-code paradigm
Imagine a scenario where the rating engine or core system would not allow easy API integration. Or even a scenario where F2Q would require a slightly modified or even a new insurance product to be configured. The backend would be the weakest link in such a scenario, and we wouldn't roll out a working app that quickly.
We could solve this by developing the premium calculation in the low-code system. However, this would also take time, and most importantly, contribute to spaghetti architecture. The rating should be provided by one unified system (unfortunately, this is not the case in reality).
As Jeff Goldberg from Novarica put it correctly, low code is not a build vs. buy decision; it still is "build" issue. Another great point the article makes is that it highlights precisely the same issues - if we are not cautious, business logic will be lost somewhere at the UI level. This should not happen, and business logic should reside in the insurance platform's PAS or claims system. The combination of these two platforms avoids the issue.
This is where we see the power of low code for the insurance industry – the integration and coexistence of low-code enterprise and insurance platforms. The future is multi-platform.
Top challenges for insurance software
Insurers looking to identify the most suitable type of low-code should analyze their specific challenges. Let's look at some of the industry's challenges and insurance software development and operations characteristics.
The insurance business model is data-heavy
Insurance core systems act as a repository for records and transactions. This is because insurance companies need to keep track of transactions and records of policies, claims, reserves, accounting and financial data, customer and agent data, and more. Each new regulation imposes additional data requirements. An example of this is the consent and audit trail data required by the GDPR.
The insurance business processes span organizations and teams
All the insurance data is used within insurance processes that cover the insurance value chain. These processes are performed by insurance teams that include internal teams such as claims adjusters, actuaries, accountants, underwriters, and external groups such as service providers, distribution partners, and more.
The insurance business model requires lots of interactions
The insurance model involves interaction with external teams such as service providers, distribution partners such as insurance agents and brokers, and more. The insurance industry is also heavily regulated, so the processes must be integrated with external systems.
The legacy of siloed and heavily customized code
A decade ago, there was almost no commercial standard insurance software. The result is a jungle of different custom and off-the-shelf solutions that are difficult to manage after a while. Even as more standardized Software emerged, insurers still adapted it heavily to meet their specific needs. After all, insurers see custom processes and products as their competitive advantage.
Consequently, insurers continue to support dozens of systems that provide critical business support for various business lines and processes (sales, claims, etc.) and deliver compliance.
An impressively high cost and a long time to market
Insurance IT organization and insurance software must meet an incredible amount of expectations: Software is here to digitize data, store it and provide secure access to systems and users who need it; Software must support insurance teams' work and digitalization of insurance processes; it is the job of Software to support all the interactions and integrations.
The complexity of replacing legacy systems, followed by heavy customization, has resulted in an impressively long IT backlog. It is difficult for IT to support this complexity level, let alone discuss supporting Innovation and new products.
The result is handicapping insurers: time to market for new products can last months, and even implementing minor changes takes weeks. Business users are fighting for scarce IT resources and increasing the requirements for complex landscape, system jungle, knowledge requirements, and more.
An end-to-end low code approach to IT is needed
To leverage the full potential of the low-code paradigm, insurers must carefully select low-code platforms that address their most pressing use cases. No one platform is a panacea; the key lies in the integration and coexistence of low-code enterprise platforms and low-code insurance platforms.
The insurance business model is so complex that it will be difficult for an insurer to survive competitors while operating legacy systems and modern low-code enterprise platforms. Without a modern digital insurance platform built on the low-code paradigm, time to market, efficiency, cost, and citizen developer empowerment are simply impossible.
AdInsure, a modern digital insurance platform designed around the no-code/low-code paradigm
AdInsure was built from the ground up to support insurers in four key areas:
- Architecture: easy integration into the emerging ecosystems and IT architectures.
- Business: empowerment for business teams to prototype new products and business models quickly.
- Operations: implementation of changes at a fraction of time and money.
- CXO: minimized regulation risk and a strong potential for consolidation.
With AdInsure, we aimed to change the game dramatically: to help insurers leverage the full talent pool on the business side, help their business users reduce their IT waiting times, and help IT reduce the effort and knowledge needed to support the business. Our goal with AdInsure Studio was to consolidate the production process across business and IT and create one tool for everyone. The platform provides the necessary architecture to support app deployment at scale, versioning, security, upgrades, infrastructure management, and accessibility. This enables companies to get essential products and business processes up and running quickly and focus skilled IT resources on solving more complex issues. It also gives a broad range of stakeholders an opportunity to test creative new ideas and gain competitive advantages.
Image: AdInsure - a low-code insurance platform
15 top features that make AdInsure a no-code/low-code insurance platform
- Insurance-specific content
When compared to most low-code platforms that do not provide insurance-specific content, AdInsure does. This includes pre-built insurance products, modular insurance-specific process support, regulation compliance. - No-code/low-code insurance product design and configuration
Coding skills are not required to create insurance products. Using AdInsure Studio product wizards and intuitive drag-and-drop editors, developing new exiting versions and configuring new products require zero coding. - No-code/low-code approach to process design
AdInsure is an end-to-end solution for designing insurance applications, quotes, binding offers, policy management (including underwriting rules), and even claims and reinsurance solutions. Automated wizards or simple scripting can be used to design and adapt these features without writing code. - Built with the citizen developer in mind
AdInsure tools are built to support the citizen developer. It provides software developers as well as citizen developers with tools to collaborate and rapidly develop insurance-related solutions. - No-code digitalization of insurance products - API
Insurance products are immediately ready for integration with other systems, distribution channels, customer portals, and for partners. Even the APIs for custom products are generated automatically. - Low-code approach to system and business ecosystem integration
Even integrations can be implemented by configuration. This includes the integration of other internal and external systems, IoT, and data. Ecosystem partner capabilities can be used via a plug-and-play configuration such as AdInsure configuration packs that can be developed without ever having to touch AdInsure code. - Features implemented as deployable configurable packs
New features and integrations can be seamlessly deployed and merged into existing insurance processes. Adding new claims or accounting features, or even a new line of business does not require coding. - No-code premium rule definition
Premium rules are easily configured in DMN tables and then compiled in JavaScript. - No-code design of customer-facing applications/UI
User-facing applications such as agent and claims adjusters portals or claims service portals can be designed without touching the code with the help of the UI Editor. All this can be done using an intuitive drag-and-drop interface. - Low-code approach to the launch of new lines-of-business
AdInsure allows insurers to manage multiple lines of business from a single platform. As a result, they can change how they bring products to market significantly; the process is smoother and faster, allowing them to launch new lines of business much more quickly. - Full configuration and development lifecycle
It covers the whole application, from design and development to testing and deployment. It offers an interface for automated testing and DevOps platforms. - Simple deployment process
AdInsure Studio provides native one-click deployment of changes and new features to different test and production environments. - Fast roll-out of minimum viable products
It is important to keep testing, evolving, and rolling out new insurance products. Business users and technologists can quickly and easily create customized products and user portals that they can test, iterate, launch, and scale if successful. - No-code localization
Language localization can be done without programming. Languages can be switched in real-time. - No-code approach to data model changes
While data models can be easily changed through the Data Editor, the data model can be also automatically changed by the use of drag-and-drop UI-Form Builder.
