The problem before the underwriting decision
Convr is an insurance technology platform focused on underwriting. Before an underwriter can judge a risk, someone has to gather the facts, and those facts tend to be spread across documents, PDFs and forms.
When that work is done by hand, it takes time and invites mistakes. Experienced underwriters can end up reading and re-keying information rather than using their judgment, and each application waits its turn.
The work here was to automate the data gathering and the checks around it. Underwriters would then start from a prepared case, with the information already extracted, standardized and validated.
What we knew before we built
No before-and-after baseline from this work is published here, so this page does not offer an improvement figure. What can be stated is what the work set out to do.
- 4
- Objectives: automate manual tasks, reduce data errors, give real-time insight and scale the workflow
- 3
- Kinds of source material to read: insurance documents, PDFs and forms
- 4
- Workflow stages to run: extraction, scoring, validation and reporting
That set three requirements for the work. Data had to come out of varied documents in one standard form. A failure at one stage could not bring down the whole workflow. And underwriters needed a clear view of what was ready for them and what state each case was in.
The approach we chose
We ran each stage of the workflow as its own service, so that each could scale separately and a fault in one would be contained:
- Modular microservices. Extraction, scoring, validation and reporting each run independently.
- Flask APIs. Lightweight Python backend APIs connect the services.
- MySQL. Structured storage for underwriting data.
- Angular dashboard. A responsive interface for underwriters and their teams.
- Docker and AWS. Containerized services, deployed and managed on AWS.
An application moves through four stages before the underwriter reviews it:
- Extract. Critical data is pulled from insurance documents, PDFs and forms, then standardized.
- Score. Industry risks, exposure types, policy details and compliance metrics are evaluated.
- Validate. The extracted information is checked.
- Report. A case summary reaches the underwriter's queue, ready for review.
What we built
Our contribution was the application engineering: backend services, data storage, the underwriter interface and cloud deployment.
Intelligent document processing
The system extracts critical data from insurance documents, PDFs and forms, and standardizes it so that it can be used for risk evaluation and profiling.
Automated risk assessment
Industry risks, exposure types, policy details and compliance metrics are evaluated automatically, to help underwriters make data-backed decisions faster.
An underwriter workflow dashboard
An Angular interface provides task queues, status updates and case summaries, and supports collaboration between underwriting teams.
A microservice backend
Each workflow stage runs as an independent service, with Flask APIs and MySQL storage, which supports scaling and fault isolation.
Cloud deployment
Services are containerized with Docker, then deployed and managed using AWS services, with reliability and scalability as the goals.
An underwriter's time should go on judging the risk, not on finding the facts.
The guardrails around underwriting
Underwriting decisions affect real customers and real risk. Automation supports those decisions, so the controls around it matter as much as the speed.
- Underwriters decide. Risk assessment supports underwriters, who review the case and make the decision.
- Validation as its own stage. Validation runs as a separate step in the workflow rather than as an afterthought.
- Fault isolation. Independent services help contain a failure to one stage of the workflow.
- Visible status. Task queues and status updates show where each case stands.
- A clear view of compliance. Regulatory obligations belong to the insurer and depend on its markets and processes. We do not describe the software as compliant in itself.
What was reported
The work delivered document extraction, automated risk assessment and an underwriter dashboard on a microservice architecture. The effects below are what the project team reported; none of them is a measured result from this work:
- Processing time. Automating repetitive tasks was reported to reduce underwriting processing time. No figure is published here.
- Accuracy. Human error in risk assessment was reported to have reduced. No figure is published here.
- Throughput. Teams were reported to be able to process more insurance applications. No figure is published here.
- Scalability. Cloud-based microservices are designed to support the business as it grows.
What stays hard
Four challenges come with this kind of platform, and any team building one should plan for them.
- Messy documents. Insurance documents, PDFs and forms vary widely, and all of them have to end up in one standard form.
- Earning underwriters' trust. People will only rely on extracted data and risk assessments if they can see the state of a case and check it.
- Many moving services. Independent services scale and fail separately, but they also have to be deployed, monitored and kept in step.
- Speed without losing judgment. Automation should remove the repetitive work while leaving the underwriting decision where it belongs.