Step 1: Define the Underwriting Problem and Target Variable 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):