I often get asked how much technical skill someone needs in order to use a low-code platform like Root. If you can’t code, it can easily seem scarier than it needs to be. Let’s unpack this and shed some light on what’s in front of you.

At Root, we enable insurance businesses to enter the digital era with our cloud based insurance infrastructure. It’s been crafted over years to be as flexible and powerful as technology allows, with the primary goal being to enable companies to focus their teams on building out differentiation, not the utility behind it. This means ensuring clear focus on the two important parts of running an insurance business: the customer experience and insurance product itself. 

The primary bottleneck in most insurance businesses

We’ve been helping companies grow their insurance businesses and empower their teams across three continents with more than 70 different insurance products. In doing so, we’ve come to learn that one of the primary pain points causing companies to look for alternative solutions is the fact that their software development capacity is bottlenecked.

Regardless if these are internal or external developers, it ends up being either too expensive or takes forever to make changes to products. Often a simple change to policy wording or update to rating tables can take more than three months (that’s unacceptable, by the way). It’s subsequently really hard to keep up with pricing improvements or regulatory changes such as consumer duty’s annual product reviews. 

Root's philosophy is that utility should be offloaded; developers should focus their scarce capacity on building differentiation and better customer experiences, not on keeping the lights on. The Root platform carries most of the heavy weight, making it easier, faster and simpler to make core changes to products.

Sometimes developers are non-optional

Offloading to a platform like Root, or any other, does not automatically mean you don’t need developers involved when iterating and changing your insurance offering.

If you’re distributing products digitally, there will always be some sort of API involved, and that means developers need to be involved. Any changes that get made on the core platform that alters the APIs - for example, changing the fields that need to be passed in - requires the API-consuming system (perhaps the customer-facing website) to also get updated at the same time.

This means that if there’s a digital front-end interface, an integration into a partner distribution channel or even a broker tool that can generate quotes, issue policies or service existing policies, any changes to the “shape” of the insurance product will require software development work in the change process.

For example, let’s say you’re adding an optional benefit to have winter sports cover on your travel insurance product, then not only do you need to change the “shape” of the product and load the rating numbers on the policy administration system, but you also need to update your website to add the checkbox for the customer to select the cover.

This holds for any platform being used, whether it's a drag-and-drop configuration tool, a low-code platform like Root, or even a fully self-built platform.

Divide and conquer; split up the parts

This brings me to the question: “so what can I change without needing to get software developers involved?” Let’s split it up.

Things that require developers to be involved:

  • Creating a new insurance product (as the APIs needs to be consumed and payment methods needs to be set up or integrated)
  • Changing the input fields or data that gets passed in to the product

Things that don’t require developers to be involved:

  • Updating email and SMS templates and rules
  • Updating document templates (schedules, certificates, etc)
  • Updating rating tables for existing input fields
  • Adding covers or benefits that don’t require any additional input from the customer (e.g. winter sports being on-by-default for your top travel package)
  • Wording and labels on input fields that are controlled by the core platform

Once a product has been configured and set up properly, the major ongoing changes can be performed without a bottleneck on software development capacity.

What skills do I need?

When adopting any new tool or system, training, onboarding and familiarization will be required. In order to be able to do the items listed above that don’t require developers to be involved, these are some of the core skills to learn:

  • For documents or email templates: basic HTML skills and working with merge variables. If the product is already set up, this usually involves copy pasting similar parts from the document
  • For rating tables, once the product is set up properly, this is a copy paste from your Excel sheet into the low-code environment
  • Click buttons to generate sample PDF docs, run test suite to ensure nothing has been broken, and finally to push the changes to the Root platform

If you’re interested to learn more about how you can unblock growth in your insurance business, or how Root’s modern cloud-based policy administration system can be leveraged, reach out to us to hear more.