Sure is building the technology rails to power modern digital insurance programs for every kind of insurance product. In order to do that at scale, our platform must be flexible, configurable, and a delight to use. A big part of that is being snappy – which means enabling high performance in our backend systems.
As the saying goes in software engineering, you can prioritize configurability and flexibility, ease of maintenance, or performance, but you can typically only choose two. The evidence of this harsh reality is all around us, as most software powering our world is either slow, rigid, or expensive and time-consuming to maintain. Even though we can’t break the fundamental tradeoffs at the crux of this issue, we’ve built an extremely powerful and configurable Rate Order Calculator (ROC) – which just so happens to be very fast.
The engine and rules to calculate prices
A ROC, in insurance industry jargon, is the engine and rules that calculate the prices that consumers pay for insurance policies. Since our technology rails support all types of complex insurance products, everything must be extremely configurable. This is a challenge we’re happy to accept – and there is no hard coding in the engine at all. Our ROC Builder system takes in configuration data and compiles it into a pricing model, which is then used to serve prices to consumers.
Here’s how it works:
When configuring a pricing model, we ingest files that are used to determine base rates and factors given various criteria (e.g., in New York, a base premium is $100, but in Ohio, it’s $75). The various files are all related together via calculations, which are mathematical expressions such as: (Base Premium) + (Factor A) + (Factor B). This is all assisted with our proprietary AI workflow to speed up the process of configuration.
Like any mathematical expression, calculations often depend on other calculations – so the complexity spikes up quickly. It’s common that there will be millions of possible permutations in simple-to-moderately complex ROCs. In some products, there will be hundreds of millions of possible permutations.
Comparable performance of simple and complex models
Complexity and performance are highly correlated in software. Our goal is to decouple the relationship between performance and complexity so that simple models and complex models have comparable performance.
This is no easy task. The naive way of implementing any pricing system is to upload lookup data into a database, and write code that can perform these lookups at price calculation time. The lookups are the slowest part of calculating a price. In order to decouple performance from complexity, our team compiles and trains the configuration data into a pricing model. At a very high level, compiling and training the ROC data into a pricing model is just doing a lot of the work ahead of time – you can think of it like pre-calculating as much as we can. This is sort of like how ChatGPT, Claude, and other Large Language Models (LLMs) are able to provide responses near instantaneously.
For your average multi-million dollar to build and configure rate order calculation in legacy systems a processing time of 200 milliseconds would be a monumental benchmark. While 200 milliseconds is considered to be fast enough for typical web requests, the team at Sure is serious about industry leading performance benchmarks – and we knew we could do better than any other rating system in the market today.
To solve for this, we rewrote the compilation and pricing algorithms from scratch, resulting in a ton of performance improvements. This optimization was massive, but it was worth the effort. Now, we’re calculating prices for even very complex ROCs in sub-100 milliseconds. We’re really proud of this result and are excited to continue pushing our platform forward at the frontier of insurance technology!
