Step 1: Define the Underwriting Problem and Target Variable

I’ve reviewed dozens of failed AI underwriting projects. The single most common cause? The target variable was ambiguous or misaligned with business outcomes. If the model predicts “loss ratio” but underwriters care more about “combined ratio,” the model will be ignored. Be surgical about what you’re optimizing.

The target must be: Observable within 12–24 months.

Actionable by underwriters (e.g., pricing, limit, deductible, exclusion). Stable—do not predict “loss ratio” if your reinsurance treaties reset every year.

• Example: Predict “next-12-month loss ratio per $1M premium” for small commercial property risks in Texas. Use NAIC Schedule P data aggregated to policy level. Validate with Texas Department of Insurance 2023 market conduct data [Texas DOI, 2023 Market Conduct Data].
• Trade-off: Granularity vs. Predictability
• If you bucket “Texas” into 254 counties, each cell must have at least 500 policies or the model will overfit. If you use ZIP-level, you’ll need at least 10,000 risks. I’ve seen teams waste six months on ZIP-level models with only 5,000 policies—causing a 20-point increase in RMSE.

Step 2: Acquire and Clean Underwriting Data I’ve built underwriting models for MGAs, carriers, and TPAs. The data pipeline is always the bottleneck. You need four sources:

Prospect/Customer Application Data: COPE (Construction, Occupancy, Protection, Exposure), revenue, number of employees. Historical Loss Data: Paid losses, IBNR, ALAE, reinsurance recoveries.

External Data: FireLine, Verisk ISO, CoreLogic property risk scores, LexisNexis commercial risk scores. Policy and Billing Data: Premium, deductible, limit, effective/expiration dates, UW class codes.

Step 2.1: Data Inventory Checklist Source

Minimum Records Retention Period

1. Key Field Data Quality Risk
2. Prospect Applications 10,000+
3. 5 years COPE fields
4. Missing COPE or revenue fields in 15% of records Historical Losses

5,000+ policies 10 years

Proximity to Coast (Miles) Distance to nearest coastline

Positive (+) 0.06

import pandas as pd

import great_expectations as ge


# Load raw loss data

df = pd.read_parquet("s3://loss-data/paid_loss_2013_2023.parquet")


# Validate

ge_df = ge.from_pandas(df)

ge_df.expect_column_values_to_not_be_null("policy_id")

ge_df.expect_column_values_to_be_between("paid_loss", 0, 10_000_000)

ge_df.expect_column_values_to_match_regex("state", "^[A-Z]{2}$")


# Clean

df["paid_loss"] = df["paid_loss"].fillna(0)

df["loss_ratio"] = df["paid_loss"] / df["written_premium"]

df.dropna(subset=["loss_ratio"], inplace=True)

Revenue per Sq Ft Annual revenue / sq ft

Negative (-) 0.05

Class Code Hazard Group NCCI or similar hazard group

Positive (+) 0.04

50–200ms Medium

import featuretools as ft


# Define entities and relationships

es = ft.EntitySet(id="commercial_property")

es = es.entity_from_dataframe(

    entity_id="policy",

    dataframe=df,

    index="policy_id",

    time_index="effective_date"

)

es = es.normalize_entity(

    base_entity_id="policy",

    new_entity_id="property",

    index="property_id",

    additional_variables=["construction_type", "roof_age"]

)


# Generate features

features, feature_names = ft.dfs(

    entityset=es,

    target_entity="policy",

    agg_primitives=["mean", "max", "min", "sum"],

    trans_primitives=["years", "divide"],

    max_depth=2

)

$25k (Licensing) Model versioning overhead

Batch Scoring (Spark) Overnight

Low $18k (Databricks)

Stale scores at UW time Hybrid (API + Batch)

100ms (API), Overnight (Batch) High

import lightgbm as lgb

import optuna


def objective(trial):

    params = {

        "objective": "regression",

        "metric": "rmse",

        "verbosity": -1,

        "boosting_type": "gbdt",

        "num_leaves": trial.suggest_int("num_leaves", 20, 300),

        "learning_rate": trial.suggest_float("learning_rate", 0.01, 0.3),

        "n_estimators": trial.suggest_int("n_estimators", 50, 500),

        "min_child_samples": trial.suggest_int("min_child_samples", 5, 100),

        "reg_alpha": trial.suggest_float("reg_alpha", 1e-8, 10.0),

        "reg_lambda": trial.suggest_float("reg_lambda", 1e-8, 10.0),

    }

    model = lgb.LGBMRegressor(**params)

    model.fit(X_train, y_train)

    return model.score(X_val, y_val)


study = optuna.create_study(direction="maximize")

study.optimize(objective, n_trials=100, timeout=3600)

df["predicted_decile"] = pd.qcut(df["predicted_loss_ratio"], 10, labels=False)

df["actual_decile"] = pd.qcut(df["actual_loss_ratio"], 10, labels=False)


decile_analysis = (

    df.groupby("predicted_decile")

    .agg(

        avg_actual_loss_ratio=("actual_loss_ratio", "mean"),

        avg_predicted_loss_ratio=("predicted_loss_ratio", "mean"),

        std_actual_loss_ratio=("actual_loss_ratio", "std"),

        count=("policy_id", "count"),

    )

    .reset_index()

)

# Dockerfile

FROM python:3.11-slim


WORKDIR /app

COPY requirements.txt .

RUN pip install --no-cache-dir -r requirements.txt


COPY .


CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]


# app.py

from fastapi import FastAPI

import joblib

import pandas as pd

from pydantic import BaseModel


model = joblib.load("model.pkl")


class UnderwritingRequest(BaseModel):

    policy_id: str

    state: str

    construction_type: str

    roof_age: int

    revenue: float

    sq_ft: float

    fireline_class: int


app = FastAPI()


@app.post("/predict")

def predict(request: UnderwritingRequest):