Automated Severity Scoring Models for Claims Automation

Automated severity scoring models translate raw FNOL telemetry into quantified risk signals that drive routing decisions. Deploying these models in production requires deterministic routing logic, hardened error boundaries, and auditable decision trails. Unlike experimental data science environments, production severity engines operate within tight latency windows, must handle malformed payloads gracefully, and must produce outputs transparent enough to satisfy state insurance commissioners and internal audit frameworks. The architecture below isolates predictive inference from business rule execution, enabling integration with Claims Triage & Routing Engines while maintaining regulatory compliance boundaries.

The reliability of any severity model is bounded by its ingestion layer. Claims and policy data arrive from telematics APIs, adjuster mobile applications, third-party repair networks, and legacy core systems. In Python production environments this requires strict schema validation before feature extraction. Malformed payloads must be quarantined rather than silently coerced, preventing model drift and compliance violations.

Copy
import logging
from datetime import datetime
from typing import Optional
from pydantic import BaseModel, Field, ValidationError, field_validator

logger = logging.getLogger(__name__)

class FNOLPayload(BaseModel):
    claim_id: str = Field(pattern=r"^CLM-\d{8,12}$")
    policy_number: str
    loss_date: str
    incident_type: str
    estimated_damage_amount: Optional[float] = Field(None, ge=0.0)
    vehicle_make: Optional[str] = None
    policy_state: str = Field(min_length=2, max_length=2)
    prior_claims_count: int = Field(ge=0)

    @field_validator("loss_date")
    @classmethod
    def parse_iso_date(cls, v: str) -> str:
        datetime.fromisoformat(v)
        return v

def ingest_fnol_payload(raw_data: dict) -> dict:
    try:
        validated = FNOLPayload.model_validate(raw_data)
        return validated.model_dump(mode="json")
    except ValidationError as e:
        logger.error("Schema validation failed: %s", e)
        raise ValueError("Invalid FNOL payload structure") from e

This validation boundary guarantees that downstream scoring functions receive only type-safe, range-constrained inputs.

Once validated, raw payloads are transformed into model-ready features. Production feature engineering must be stateless, idempotent, and version-controlled for regulatory audits. Common transformations include temporal decay weighting, categorical encoding, and missing-value imputation using policy-level defaults rather than dataset-wide means.

Copy
import numpy as np
from datetime import datetime, timezone
from typing import Dict, Any

def extract_severity_features(payload: Dict[str, Any]) -> Dict[str, float]:
    features: Dict[str, float] = {}

    # Temporal decay: older incidents typically carry lower immediate severity
    loss_dt = datetime.fromisoformat(payload["loss_date"])
    if loss_dt.tzinfo is None:
        loss_dt = loss_dt.replace(tzinfo=timezone.utc)
    days_since_loss = (datetime.now(timezone.utc) - loss_dt).days
    features["temporal_decay_weight"] = max(0.1, np.exp(-days_since_loss / 30.0))

    # Prior claims (capped to limit outlier distortion)
    features["prior_claims_normalized"] = min(payload["prior_claims_count"], 5) / 5.0

    # Log-transformed damage estimate; fall back to policy default baseline
    raw_damage = payload["estimated_damage_amount"]
    features["log_damage"] = np.log1p(raw_damage if raw_damage is not None else 2500.0)

    # Incident-type base severity
    incident_map = {"collision": 1.0, "comprehensive": 0.7, "liability": 0.9}
    features["incident_severity_base"] = incident_map.get(
        payload["incident_type"].lower(), 0.5
    )

    return features

This extraction layer operates independently of the inference engine, enabling feature versioning without model retraining.

Production severity scoring uses a hybrid architecture: a calibrated probabilistic model provides a base score; explicit business rule modifiers apply coverage boundaries and policy exclusions. Regulatory frameworks demand transparent, deterministic components that can be reviewed during dispute resolution.

Copy
import joblib
from typing import Dict, Any

# Load pre-calibrated model (e.g., LightGBM or XGBoost with isotonic calibration)
SEVERITY_MODEL = joblib.load("models/severity_calibrated_v3.pkl")

def compute_severity_score(features: Dict[str, float], policy_state: str) -> Dict[str, Any]:
    feature_vector = [
        features["temporal_decay_weight"],
        features["prior_claims_normalized"],
        features["log_damage"],
        features["incident_severity_base"],
    ]

    raw_score = float(SEVERITY_MODEL.predict([feature_vector])[0])

    # Regulatory routing cap for select high-litigation states
    if policy_state in ["CA", "NY", "FL"]:
        raw_score = min(raw_score, 0.85)

    final_score = max(0.01, min(0.99, raw_score))

    return {
        "severity_score": round(final_score, 4),
        "confidence_interval": (round(final_score - 0.05, 4), round(final_score + 0.05, 4)),
        "model_version": "v3.1.2",
        "rule_applied": "state_cap_enforcement" if policy_state in ["CA", "NY", "FL"] else "none",
    }

Modifiers are applied post-inference to prevent training data leakage and maintain model calibration integrity.

Every severity output must map to regulatory requirements. State insurance departments require explicit documentation of how automated decisions affect claim handling. Structured logging aligned with the NIST AI Risk Management Framework captures input payloads, feature transformations, model versions, and applied business rules.

Copy
import json
import uuid
import hashlib
from datetime import datetime, timezone

def generate_audit_record(
    claim_id: str,
    payload: dict,
    features: dict,
    score_result: dict,
) -> dict:
    canonical_payload = json.dumps(payload, sort_keys=True, separators=(",", ":"))
    return {
        "audit_id": str(uuid.uuid4()),
        "timestamp": datetime.now(timezone.utc).isoformat(),
        "claim_id": claim_id,
        "input_hash": hashlib.sha256(canonical_payload.encode("utf-8")).hexdigest(),
        "features_applied": features,
        "score_result": score_result,
        "compliance_flags": {
            "gdpr_data_minimization": True,
            "state_regulatory_alignment": True,
            "explainability_artifacts_attached": True,
        },
    }

Audit records are serialized to immutable storage and indexed by claim ID. Aligning with NAIC Model Audit Rule guidelines ensures that automated scoring pipelines meet statutory documentation requirements across jurisdictions.

Severity scores act as routing signals. Thresholds determine whether claims proceed through straight-through processing (STP), require specialist adjuster review, or trigger fraud investigation.

Copy
def determine_routing_action(severity_score: float, prior_claims: int) -> str:
    if severity_score >= 0.85:
        return "high_severity_specialist_queue"
    elif severity_score >= 0.60:
        return "standard_adjuster_pool"
    elif prior_claims >= 3:
        return "fraud_investigation_hold"
    else:
        return "automated_stp_processing"

When integrated with Adjuster Assignment Algorithms, severity scores dynamically balance workload distribution across appropriately licensed specialists.

Production severity pipelines must survive upstream degradation, model staleness, and infrastructure failures. Key operational metrics:

• P99 latency: target < 250 ms for synchronous FNOL processing
• Schema rejection rate: monitor for upstream API changes
• Score distribution drift: alert when Population Stability Index (PSI) exceeds 0.25
• Fallback activation rate: trigger rule-based baseline scoring when ML inference fails

By enforcing strict validation at ingestion, isolating inference from business logic, and generating immutable audit trails, InsurTech teams can deploy scoring pipelines that scale reliably while satisfying compliance mandates. The hybrid architecture — probabilistic model base score plus deterministic rule modifiers — is the practical pattern for production: it delivers predictive accuracy where data supports it and falls back to auditable rules where regulators require explicit justification.