why travel insurance underwriting is broken — and why we’re fixing it in 10 weeks
Last year, four of the largest US travel insurers paid out $1.2 billion in claims they could have declined in under 60 seconds with better data. This isn’t bad luck; it’s bad underwriting. Traditional travel policies still use paper forms, static rules engines, and 1990s-era MIB (Medical Information Bureau) checks that take 24–48 hours to decide whether a $300 trip is worth underwriting. Priced-in fraud alone costs the segment 4.7% of premium, according to III (2023, “Travel Insurance Fraud Study”).
At our MGA, we decided to cut that latency from days to milliseconds. Starting in January 2024, we ran a zero-to-Sixty pilot on a $12 million ticket book, embedding real-time AI underwriting directly into the airline and OTA checkout flow. Conversion jumped 11.3 points, loss ratio fell 2.9 points, and we returned the build cost in 8 weeks. Here’s the 10-week plan we used to get there.
the four technical pillars of real-time travel underwriting
To go from batch to real time, we built four tightly coupled systems. Each pillar carries a specific risk if misdesigned; we learned this the hard way when our first rule engine produced 17 false declines in a single day.
pillar 1: low-latency identity graph
Travel underwriting hinges on two things: who the traveler is and what they’re doing. We needed a single identity graph that could resolve a passenger ID, passport, or driver’s license in under 300 ms and feed downstream models without cross-region latency.
- source: we ingested IATA passenger name records (PNR) in real time via AWS PrivateLink, stripping PII before storage to comply with GDPR and CPRA.
- failure mode: an early design that cached PNRs in DynamoDB caused a 4.2% drop in match accuracy when travelers changed middle names between bookings. Switching to a streaming Kafka topic with a probabilistic Bloom filter reduced latency to 220 ms and lifted match accuracy to 99.1%.
pillar 2: dynamic risk scoring engine
Our first model was a static 2019 XGBoost trained on 2017–2019 claims. By 2024, it was recommending declines on perfectly healthy 65-year-olds simply because the training data lacked post-pandemic travel behavior. We rebuilt the pipeline in MLflow on Databricks, retraining every 2 hours on 12 months of new claims, MIB adverse events, and CDC travel health notices.
- latency target: 50 ms per passenger pair.
- guardrail: we capped the score delta at ±15 points within any 24-hour window to prevent sudden swings that would break the checkout flow.
pillar 3: payment velocity control
Real-time underwriting can’t ignore velocity. A single traveler purchasing six back-to-back policies in 15 minutes is a classic fraud signal. We built a Redis-based sliding-window counter per device + email hash. When velocity exceeds 2 policies / 60 minutes, we trigger a step-up to liveness selfie verification.
- false positive cost: in month 1, the velocity gate blocked 0.8% of legitimate purchases, mostly family bookings. We added a 24-hour velocity cap per household and reduced false positives to 0.2%.
pillar 4: policy pricing micro-hedge
Underwriting and pricing must move together. We coupled our underwriting score to a real-time pricing curve that updates every 15 minutes. A score drop of 10 points raises the base premium by 8%, but only if the combined ratio for that segment is >105%. We use Snowflake Cortex for the real-time curve and Redis Streams for event ingestion.
Trade-off: every 10 ms increase in curve latency adds $17k of unhedged risk on a $1 B annual book — we learned this when a weekend Snowflake outage pushed latency to 280 ms and our hedge ratio dropped 1.3 points.
week-by-week build plan — what actually worked
The plan below compresses a 12-week enterprise build into 10 weeks by ruthlessly prioritizing production code over prototypes and flipping the QA cycle left of development.
| week | deliverable | key actions | measure of done |
|---|---|---|---|
| week 1 | identity pipeline v0 | Stand up AWS PrivateLink to airline PNR feed, build anonymized passenger hash, deploy Kafka topic with 50 GB retention. | 95% passenger match in <300 ms end-to-end. |
| week 2 | fraud velocity layer | Implement Redis sliding window, add household velocity cap, log all velocity triggers. | False positives <1% on 1,000 sandbox purchases. |
| week 3 | underwriting score v0 | Train XGBoost on 2023 claims, run shadow mode on 20% of traffic, score every passenger. | Shadow mode accuracy = 87% vs. historical decisions. |
| week 4 | pricing micro-hedge | Link score to Snowflake Cortex curve, back-test combined ratio impact over 6 months. | Combined ratio improvement ≥1.5 points. |
| week 5 | checkout embed v1 | Inject real-time widget into airline checkout using iframe sandbox, measure latency SLA. | Widget load <1.2 s on 95th percentile. |
| week | model retraining loop | Build Databricks MLflow job, schedule every 2 hours, add CDC for MIB adverse events. | Model drift MAE <0.03 per 2-week window. |
| week 7 | compliance & privacy | Run SOC 2 type I audit, redact PII in event store, encrypt PNR data at rest. | SOC 2 clean report, 0 PII leaks in 30-day pen test. |
| week 8 | production cutover | Flip traffic from shadow to live at 5% volume, monitor combined ratio hourly. | Combined ratio ≤102% for 72 consecutive hours. |
| week 9 | performance tuning | Add Redis caching layer for frequent passengers, optimize Kafka partition count. | Latency <70 ms 99th percentile. |
| week 10 | scale & optimize | Run load test at 2× peak traffic, finalize SOC 2 type II, hand off to DevOps runbook. | Sustained 5,000 transactions/minute, 0 critical alerts. |
Our biggest misstep was week 4. We assumed the pricing curve could live in a static Snowflake table updated nightly. When COVID travel alerts spiked overnight, the curve lagged by 15 hours, and we wrote $800k of unhedged exposure. Lesson: micro-hedge curves must be streaming.
choosing the right embedded distribution layer — airline vs OTA vs super-app
Embedding where the traveler already is sounds obvious, but each channel has very different latency budgets and data contracts. We tested three paths in parallel.
| channel | latency budget | data contract | implementation risk |
|---|---|---|---|
| airline checkout | 1.2 s total page load | IATA PNR + e-ticket JSON | PCI-DSS & IATA EDIFACT parsing complexity |
| online travel agency (OTA) | 2.5 s total page load | JSON schema via REST, no PNR | Rate limiting, high concurrency spikes |
| super-app mini-program | 0.8 s total page load | WeChat/Alipay event bus | Tencent/Alibaba sandbox approval delays |
Our airline checkout won on speed but lost on payload richness. OTA gave us cleaner JSON but added 1.3 s of latency, which killed conversion on mobile. We ended up building two widgets: a 1.1 s airline version and a 2.2 s OTA version, each with a progressive disclosure toggle so travelers can skip underwriting if they already have coverage.
Risk scenario: when British Airways turned on our widget in March 2024, we saw a 9% uplift in policy sales but a 3.2% rise in claims frequency for passengers who bought within 10 minutes of booking. The issue was dynamic pricing leakage—our curve hadn’t yet factored in BA’s cabin class upgrade events. We fixed it by adding cabin class as a feature in week 8.
how to price real-time underwriting without breaking your combined ratio
Real-time underwriting changes the pricing game in three ways: it lowers adverse selection, it exposes you to quote-to-bind latency arbitrage, and it gives you a new data stream to price by. Most MGAs get this wrong by simply adding a “speed fee.”
We modeled three pricing strategies on our $12 M pilot and measured the impact on combined ratio after 90 days.
| pricing strategy | mechanism | combined ratio impact | implementation complexity |
|---|---|---|---|
| flat speed fee | add $4.99 to every quote that uses real-time underwriting | +2.3 points (bad: discourages adoption) | low |
| risk-adjusted curve | tie premium uplift directly to underwriting score delta | -1.8 points (good) | medium |
| dynamic micro-adjust | update premium every 15 minutes using Snowflake Cortex streaming curve | -2.9 points (best) | high |
The dynamic micro-adjust strategy worked because it turned underwriting data into a pricing signal. Travelers who were flagged but ultimately accepted paid 6% more on average, offsetting the 4.7% fraud cost we cited earlier. The model learned to charge less for low-velocity travelers with strong identity matches, which improved take-up without eroding margin.
Counter-argument: some actuaries warn that streaming curves can overfit to short-term noise. In our case, adding a 60-day rolling average as a smoothing factor reduced the noise by 34% without hurting combined ratio, proving the skeptics partially right but not fatal.
measuring success — the three KPIs that matter
Most MGAs track premium volume and combined ratio and call it a day. With real-time underwriting, three new KPIs dominate.
- quote-to-bind latency: time from passenger details entered to policy issued. Target: <60 s 95th percentile.
- underwriting precision: % of declined applicants who would have filed a claim within 30 days if accepted. Target: >70% precision.
- velocity-adjusted loss ratio: loss ratio divided by policy velocity (policies / traveler / year). Target: <85%.
In our pilot, we hit 52 s latency, 74% precision, and 83% velocity-adjusted loss ratio. When we widened the underwriting aperture to accept older travelers, precision dropped to 67% and loss ratio spiked to 91%. Lesson: precision beats aperture every time.
the hidden cost — tech debt from real-time underwriting
We saved $800k in unhedged exposure in week 4, but we created $210k of new tech debt. The biggest sources:
- Snowflake Cortex streaming curve cost: $18k/month at 5,000 transactions/minute.
- Redis Enterprise cluster for velocity gates: $9k/month for multi-AZ HA.
- MLflow model registry on Databricks: $4k/month plus 2 FTE data scientists.
To stay under $300k annual run rate, we ruthlessly pruned features: we removed the household graph after week 6 when it contributed <0.3% to precision, and we sunset the nightly batch pricing curve that had been costing $4k/month with zero uplift.
We also discovered that running real-time underwriting on AWS Graviton instances cut compute spend by 23% without latency regression, a switch we made in week 9.
what to do next — three immediate actions if you’re an MGA
- Run a 2-week shadow mode on your top 20% of premium-producing channels. Use your existing underwriting rules as the baseline and measure precision vs. latency. We used the Shadow Underwriting open-source toolkit to replay real claims data through our model in real time. Within two weeks we saw a 6-point precision lift and cut latency from 24 hours to 45 minutes.
- Negotiate a data-sharing agreement with one airline or OTA. Start with a narrow product line—cruise or adventure sports—to minimize scope. We inked a deal with Royal Caribbean in April 2024 that gave us real-time passenger manifests in exchange for a 2% revenue share on policies sold onboard. The manifests alone lifted our identity match rate from 89% to 97%.
- Build a minimal pricing curve that updates hourly using CDC travel health notices. Use Snowflake’s external functions to pull notices every 60 minutes and adjust base premiums by destination risk tier. We cut our first version in 3 days using a pre-built Snowflake CDC connector and saw a 1.1-point combined ratio improvement within 30 days.
Real-time AI underwriting is no longer a moonshot for travel insurance. It’s a 10-week build with measurable ROI, if you design for latency, precision, and cost from day one. The carriers who wait will cede margin to MGAs who embed underwriting where the traveler already is—and they’ll pay for it in higher claims, slower growth, and eroding trust.
Comments