Insurance Expert

Expert guidance for insurance systems, underwriting, claims processing, actuarial analysis, risk assessment, fraud detection, and modern insurtech solutions.

Core Concepts

Insurance Systems

• Policy Administration Systems (PAS)
• Claims Management Systems
• Underwriting workstations
• Actuarial modeling systems
• Reinsurance management
• Agency management systems
• Document management

Insurance Types

• Property & Casualty (P&C)
• Life insurance
• Health insurance
• Auto insurance
• Commercial insurance
• Specialty insurance
• Cyber insurance

Standards and Regulations

• ACORD standards (insurance data exchange)
• SOX compliance
• State insurance regulations
• NAIC (National Association of Insurance Commissioners)
• GDPR for customer data
• Anti-money laundering (AML)

Claims Management System

from enum import Enum

class ClaimStatus(Enum):
    REPORTED = "reported"
    INVESTIGATING = "investigating"
    APPROVED = "approved"
    DENIED = "denied"
    CLOSED = "closed"

@dataclass
class Claim:
    """Insurance claim"""
    claim_number: str
    policy_number: str
    claim_type: str  # 'collision', 'theft', 'liability', etc.
    date_of_loss: datetime
    reported_date: datetime
    description: str
    estimated_loss: Decimal
    status: ClaimStatus
    adjuster_id: Optional[str]
    reserve_amount: Decimal
    paid_amount: Decimal
    deductible: Decimal

class ClaimsManagementSystem:
    """Claims processing and management"""

    def __init__(self):
        self.claims = {}
        self.fraud_detector = FraudDetectionSystem()

    def file_claim(self, claim_data: dict) -> Claim:
        """File new insurance claim"""
        claim_number = self._generate_claim_number()

        claim = Claim(
            claim_number=claim_number,
            policy_number=claim_data['policy_number'],
            claim_type=claim_data['claim_type'],
            date_of_loss=claim_data['date_of_loss'],
            reported_date=datetime.now(),
            description=claim_data['description'],
            estimated_loss=Decimal(str(claim_data.get('estimated_loss', 0))),
            status=ClaimStatus.REPORTED,
            adjuster_id=None,
            reserve_amount=Decimal('0'),
            deductible=Decimal(str(claim_data.get('deductible', 0))),
            paid_amount=Decimal('0')
        )

        # Fraud detection screening
        fraud_result = self.fraud_detector.screen_claim(claim)
        if fraud_result['fraud_score'] > 0.8:
            claim.status = ClaimStatus.INVESTIGATING
            self._flag_for_siu(claim, fraud_result)  # Special Investigation Unit

        # Auto-assign adjuster
        claim.adjuster_id = self._assign_adjuster(claim)

        # Set reserve amount
        claim.reserve_amount = self._calculate_reserve(claim)

        self.claims[claim_number] = claim

        return claim

    def investigate_claim(self, claim_number: str) -> dict:
        """Investigate claim details"""
        claim = self.claims.get(claim_number)
        if not claim:
            return {'error': 'Claim not found'}

        claim.status = ClaimStatus.INVESTIGATING

        # Gather evidence
        investigation_steps = [
            'Review policy coverage',
            'Verify loss details',
            'Inspect damage',
            'Review police report (if applicable)',
            'Interview claimant',
            'Review medical records (if applicable)',
            'Obtain repair estimates'
        ]

        return {
            'claim_number': claim_number,
            'status': claim.status.value,
            'investigation_steps': investigation_steps,
            'estimated_completion': (datetime.now() + timedelta(days=14)).isoformat()
        }

    def approve_claim(self, claim_number: str, approved_amount: Decimal) -> dict:
        """Approve claim for payment"""
        claim = self.claims.get(claim_number)
        if not claim:
            return {'error': 'Claim not found'}

        # Validate coverage
        if not self._validate_coverage(claim):
            return {'error': 'Loss not covered under policy'}

        # Apply deductible
        payment_amount = approved_amount - claim.deductible
        if payment_amount <= 0:
            return {'error': 'Approved amount does not exceed deductible'}

        claim.status = ClaimStatus.APPROVED
        claim.paid_amount = payment_amount

        # Process payment
        payment_result = self._process_payment(claim, payment_amount)

        return {
            'claim_number': claim_number,
            'approved_amount': float(approved_amount),
            'deductible': float(claim.deductible),
            'payment_amount': float(payment_amount),
            'payment_method': payment_result['method'],
            'payment_date': datetime.now().isoformat()
        }

    def deny_claim(self, claim_number: str, reason: str) -> dict:
        """Deny claim"""
        claim = self.claims.get(claim_number)
        if not claim:
            return {'error': 'Claim not found'}

        claim.status = ClaimStatus.DENIED

        # Send denial letter
        self._send_denial_letter(claim, reason)

        return {
            'claim_number': claim_number,
            'status': 'denied',
            'reason': reason,
            'appeal_deadline': (datetime.now() + timedelta(days=60)).isoformat()
        }

    def _calculate_reserve(self, claim: Claim) -> Decimal:
        """Calculate reserve amount for claim"""
        # Reserve is an estimate of total claim cost
        # Based on claim type and severity
        reserve_multipliers = {
            'collision': Decimal('1.5'),
            'theft': Decimal('1.3'),
            'liability': Decimal('2.0'),
            'comprehensive': Decimal('1.4')
        }

        multiplier = reserve_multipliers.get(claim.claim_type, Decimal('1.5'))
        reserve = claim.estimated_loss * multiplier

        return reserve

    def _assign_adjuster(self, claim: Claim) -> str:
        """Auto-assign claim to adjuster"""
        # Would use load balancing and expertise matching
        return "ADJ001"

    def _validate_coverage(self, claim: Claim) -> bool:
        """Validate that loss is covered under policy"""
        # Would check policy coverages against claim type
        return True

    def _process_payment(self, claim: Claim, amount: Decimal) -> dict:
        """Process claim payment"""
        # Integration with payment system
        return {'method': 'direct_deposit', 'transaction_id': 'TXN123'}

    def _flag_for_siu(self, claim: Claim, fraud_result: dict):
        """Flag claim for Special Investigation Unit"""
        # Implementation would notify SIU
        pass

    def _send_denial_letter(self, claim: Claim, reason: str):
        """Send claim denial letter"""
        # Implementation would generate and send letter
        pass

    def _generate_claim_number(self) -> str:
        import uuid
        return f"CLM-{uuid.uuid4().hex[:10].upper()}"

class FraudDetectionSystem:
    """Fraud detection for claims"""

    def screen_claim(self, claim: Claim) -> dict:
        """Screen claim for fraud indicators"""
        fraud_score = 0.0
        indicators = []

        # Check for suspicious patterns
        # Late reporting
        days_to_report = (claim.reported_date - claim.date_of_loss).days
        if days_to_report > 30:
            fraud_score += 0.2
            indicators.append('Late reporting')

        # High loss amount
        if claim.estimated_loss > Decimal('50000'):
            fraud_score += 0.15
            indicators.append('High loss amount')

        # Multiple claims (would check historical data)
        # Implementation would query claim history

        return {
            'fraud_score': fraud_score,
            'indicators': indicators,
            'recommendation': 'investigate' if fraud_score > 0.5 else 'proceed'
        }

Actuarial Analysis

import numpy as np
from scipy import stats

class ActuarialAnalysis:
    """Actuarial modeling and analysis"""

    def calculate_loss_ratio(self,
                            total_claims_paid: Decimal,
                            total_premiums_earned: Decimal) -> dict:
        """Calculate loss ratio"""
        if total_premiums_earned == 0:
            return {'error': 'No premiums earned'}

        loss_ratio = (total_claims_paid / total_premiums_earned) * 100

        # Interpret loss ratio
        if loss_ratio < 60:
            assessment = "Profitable"
        elif loss_ratio < 75:
            assessment = "Target range"
        elif loss_ratio < 100:
            assessment = "Unprofitable"
        else:
            assessment = "Significant losses"

        return {
            'loss_ratio': float(loss_ratio),
            'claims_paid': float(total_claims_paid),
            'premiums_earned': float(total_premiums_earned),
            'assessment': assessment
        }

    def calculate_combined_ratio(self,
                                 loss_ratio: float,
                                 expense_ratio: float) -> dict:
        """Calculate combined ratio"""
        combined_ratio = loss_ratio + expense_ratio

        profitable = combined_ratio < 100

        return {
            'combined_ratio': combined_ratio,
            'loss_ratio': loss_ratio,
            'expense_ratio': expense_ratio,
            'profitable': profitable,
            'underwriting_gain_loss': 100 - combined_ratio
        }

    def estimate_reserves(self, claim_data: List[dict]) -> dict:
        """Estimate loss reserves using chain ladder method"""
        # Simplified chain ladder method
        # In production, would use more sophisticated methods

        open_claims = [c for c in claim_data if c['status'] != 'closed']
        total_incurred = sum(c['paid_amount'] + c['reserve'] for c in open_claims)

        return {
            'total_reserve': total_incurred,
            'open_claim_count': len(open_claims),
            'method': 'chain_ladder'
        }

    def price_product(self,
                     expected_claims: Decimal,
                     expense_ratio: float,
                     profit_margin: float) -> Decimal:
        """Calculate premium for insurance product"""
        # Pure premium (expected losses)
        pure_premium = expected_claims

        # Load for expenses
        expense_load = pure_premium * Decimal(str(expense_ratio / 100))

        # Load for profit
        profit_load = pure_premium * Decimal(str(profit_margin / 100))

        # Total premium
        total_premium = pure_premium + expense_load + profit_load

        return total_premium.quantize(Decimal('0.01'))

Best Practices

Underwriting

• Use consistent risk assessment criteria
• Implement automated underwriting for simple cases
• Maintain underwriting guidelines documentation
• Use predictive analytics for risk scoring
• Conduct regular portfolio reviews
• Segment risks appropriately
• Monitor loss ratios by segment

Claims Processing

• Provide 24/7 claim reporting
• Assign adjusters quickly
• Set appropriate reserves
• Communicate regularly with claimants
• Implement fraud detection
• Track claim cycle time
• Use photos and video for inspections

Fraud Prevention

• Screen all claims for fraud indicators
• Use predictive analytics
• Maintain Special Investigation Unit (SIU)
• Share fraud data industry-wide
• Train staff on fraud detection
• Implement identity verification
• Monitor for organized fraud rings

Compliance

• Maintain state licensing
• Follow NAIC model laws
• Implement proper data privacy controls
• Conduct regular compliance audits
• Maintain required reserves
• File timely regulatory reports
• Follow fair claims practices

Anti-Patterns

❌ Manual underwriting for all policies ❌ No fraud detection system ❌ Slow claims processing ❌ Inadequate loss reserves ❌ Poor customer communication ❌ No data analytics ❌ Ignoring regulatory changes ❌ Inconsistent underwriting decisions ❌ No claims automation

Reference Documentation

Detailed material lives alongside this skill and is read on demand:

• Policy Administration System

Resources

• ACORD Standards: https://www.acord.org/
• NAIC (National Association of Insurance Commissioners): https://www.naic.org/
• ISO (Insurance Services Office): https://www.verisk.com/iso/
• Society of Actuaries: https://www.soa.org/
• Casualty Actuarial Society: https://www.casact.org/
• Insurance Information Institute: https://www.iii.org/
• A.M. Best (ratings): https://www.ambest.com/