Root Engineering: How We Built an Insurance Company—From Scratch

First things first: Root is an auto insurance carrier, just like Geico and Progressive—except not quite like Geico and Progressive.

We’re different because we use data science to identify and insure good drivers, significantly reducing insurance premiums for good drivers as a result.

We’ve been working on building Root for nearly two years now. It’s taken a lot of hard work to build the entire infrastructure to run an insurance company—and with only a handful of engineers. And now that we’ve successfully launched? We want to share our story and a little bit about what we’re up to.

First, let’s talk about the Root idea.

We started Root because we saw two big opportunities in the car insurance industry:

  • The opportunity to leverage technology to build a better user experience. Technology is clearly not the core competency of the main players in the car insurance industry. All of the major insurance carriers have mobile apps, of course, but many of the carriers are still struggling to adapt to the age of the Internet—much less build elegant mobile experiences.

    In short, mobile is the future—and the big players in car insurance simply weren’t taking advantage of it. So we saw an opportunity. Why not embrace new technology instead of tolerate it? Why not build a car insurance experience built and designed to work on mobile? After all, phones are always connected to the internet, always within reach, and always fast to engage with. We envisioned an insurance product that mirrored the mobile experience: simple, fast, convenient, and easy.

  • The opportunity to price car insurance based on how people actually drive. There’s a fundamental problem in how companies price their insurance products. Right now, car insurance companies only look at demographics — factors like age, gender, and credit score — when quoting rates. While this system works just fine for insurance companies, it’s inherently unfair to individual drivers.

    After all, two people of the same age, gender, and credit score could drive very differently. For instance, Person A might be safe, responsible, and an infrequent driver, while Person B might be aggressive, reckless, and drive frequently on hazardous routes.

    Clearly, those two people should not be paying the same price for their car insurance. But right now they are, because big insurance companies judge customers purely by demographics.

The Root response? We wanted to gather data via a mobile app to determine how well each individual drives—and then incorporate that data into our pricing model.

A crazy idea? Maybe. But the data supported it: we discovered that the majority of insurance claims come from the worst drivers, and that 68% of people—the good drivers—should be paying less than they’re paying right now. Because we could take into account individual driving habits, we would be able to give our very best tier of drivers a 40% discount off traditional insurance pricing—a substantial savings for a lot of people! Besides the cost savings, though, our proposed system would be fairer and more human.

It was worth a shot.

Root was founded on the crazy idea that insurance should be fair, simple, and human. Here’s how we made that idea work.

When we first started the company, we didn’t think we’d become an insurance carrier right away. The regulatory hurdle is high, and we thought it might be insurmountable—especially with a small team and limited resources. So we started by simply building a mobile app to gather driving data, thinking we could partner with an existing insurance carrier to handle the underwriting and insurance concerns.

But after meeting with numerous carriers, we realized it wasn’t going to be quite so simple.

A typical conversation went like this:

Root: “We’d like to show people their quote in a mobile app. If you have an API endpoint where we can retrieve pricing information, we’ll fetch it and show it in the app.”

Potential Partner: “We don’t have any APIs right now, but we might be able to build a SOAP service in our Q3 roadmap next year.”

Root: “Okay, and once we have that, we also want people to be able to purchase a policy right in the app. We’ll ask for a credit card number, and then we’ll send that you to in another API call to handle billing.”

Carrier: “Oh, we can’t do credit cards over an API. What if you show the person an 800 number in the app and they can call us if they want to purchase a policy?”

Root: “......”

Clearly, partnering wasn’t going to work. To build the user experience that we wanted to create, we were going to have to become an insurance carrier ourselves. That meant we would have to build an entire insurance infrastructure ourselves. End to end. From scratch.

It was a daunting prospect, to say the least. But we decided to attack the schlep head-on.

How we built the user interface for Root

First, we went back to work on our iOS app. Although it was tempting to develop iOS and Android side by side, it made more strategic sense to test the product/market fit on iOS before we replicated our efforts on a second platform.

At Root, we approach projects by tackling the riskiest parts first. And, while we were confident we could build a UI around the insurance process, we knew that the trickiest challenge was definitely going to be the accurate collection of driving data—so that’s where we started.

After a lot of effort, we got everything working: We learned to detect when a customer starts driving and then to start reading from the sensors on the phone. When the drive ended, we serialized all of the sensor data as JSON, gzipped it, and then uploaded it directly from the phone to a scalable storage system. That gave David, our lead data scientist, exactly what he needed to get to work on our risk assessment algorithms. So far, so good.

Now that we knew how to gather driving data, we started building the UI, leveraging the phone’s capabilities to make the process as easy as possible. Since we need driver’s license information to generate a quote, we decided to use mobile camera capabilities to read the barcode on the back of the license directly — instead of making a customer type in all of their information. This UI strategy drastically streamlined the process of sign-up.

We designed the UI to allow customers to personalize coverage once they receive a quote. After customizing their coverage, the customer could then buy an insurance policy directly through the app. We support ApplePay, so if a credit card has been saved to the device, it only takes placing a thumb on the Touch ID sensor to complete the process.

All of these UI tweaks made it possible to purchase an insurance policy from Root without using the keyboard on the phone at all: when signing up, customers could now choose to log in with Facebook, use the camera on the phone to read their license barcode, then purchase a policy with ApplePay. A series of quick taps, and the process was complete.

We had a UI we could be proud of.

How we built the backend system for Root

Of course, we also needed to create a backend system to sell insurance. From scratch. This project involved building two large, complex components: a rating engine and a policy management system.

Rating calculations are complex. We’re almost certainly the only insurance carrier that has a Google Sheets-driven platform implemented in Ruby on Rails for calculating insurance rates. We looked at some off-the-shelf options for building this, but realized that third party platforms were going to be expensive and constraining, and the better approach was building a system ourselves.

We integrated with numerous third parties to fetch the data required to rate. Rather than ask people for their life history in the app, we relied on reports like Motor Vehicle Reports and Vehicle Registration Reports to get the information that we needed. We were even able to use external reports to figure out the drivers and vehicles that a customer would likely want on their policy (with 90% accuracy), eliminating the need for most of the data entry typically required to get a policy. In cases when we miss a driver or vehicle, we provide the ability to manually add it.

Our policy management system was built in house. We decided to generate policy documents and mail out physical insurance cards like any other insurance company, but we also made sure to provide a digital insurance card within the app. Also, we created a system to calculate premium, generate accounting reports, handle billing, and support endorsements (the official insurance jargon for making a change to a policy).

Where is Root today?

Victory is sweet. After a long and arduous process, Root became a licensed insurance carrier with the Ohio Department of Insurance and we officially launched late in 2016.

The response has been tremendous. We’re selling insurance policies on a daily basis. The excitement and momentum is palpable. Customers are astonished at how incredibly simple the process is and that their insurance premiums are so much lower.

Building the entire Root Insurance platform from scratch was only possible because of the outstanding skill and hard work from our team—which consisted of only four engineers for much of our early history. Changing the car insurance industry is a big undertaking, but by assembling a team of exceptional and passionate people, we’re doing it.

And we’re excited about where we’re going.

Enjoy the Root backstory? Stay tuned! Our next post will cover how we’ve approached automated testing of our React Native mobile client. Want to stay updated? Follow us on Facebook and Instagram.

Get new posts in your Inbox

Now in the App Store

App store
ROOT for iPhone