PEPY Normalization Engine

python
# PEPY Normalization from PMPM
def convert_pmpm_to_pepy(claims_data, enrollment_data):
    # Step 1: Calculate total cost and member months
    total_cost = claims_data.total_paid_claims
    total_member_months = claims_data.total_member_months
    pmpm = total_cost / total_member_months
    
    # Step 2: Analyze coverage tier distribution
    tier_distribution = enrollment_data.groupby('coverage_tier').agg({
        'employee_count': 'count',
        'covered_lives': 'sum'
    })
    
    # Coverage Tier Typical Ratios:
    # Single: 1.0 life per employee
    # Employee + Spouse: 2.0 lives per employee
    # Employee + Children: 2.8 lives per employee (avg 1.8 kids)
    # Family: 3.2 lives per employee (spouse + 2.2 kids avg)
    
    tier_ratios = {
        'single': 1.0,
        'employee_spouse': 2.0,
        'employee_children': 2.8,
        'family': 3.2
    }
    
    # Step 3: Calculate average lives per employee
    total_employees = tier_distribution['employee_count'].sum()
    total_covered_lives = tier_distribution['covered_lives'].sum()
    avg_lives_per_employee = total_covered_lives / total_employees
    
    # Step 4: Convert PMPM to PEPY
    # PEPY = PMPM × 12 months × avg_lives_per_employee
    pepy = pmpm * 12 * avg_lives_per_employee
    
    # Step 5: FTE Adjustment (if applicable)
    if 'fte_status' in enrollment_data.columns:
        avg_fte = enrollment_data['fte_hours'].mean() / 2080  # 2080 = full-time annual hours
        pepy_fte_adjusted = pepy / avg_fte
    else:
        pepy_fte_adjusted = pepy
    
    return {
        'pmpm': pmpm,
        'avg_lives_per_employee': avg_lives_per_employee,
        'pepy': pepy,
        'pepy_fte_adjusted': pepy_fte_adjusted,
        'tier_distribution': tier_distribution,
        'total_employees': total_employees,
        'total_covered_lives': total_covered_lives
    }

# Benchmarking Example
def compare_pepy_across_employers(company_a, company_b):
    a_result = convert_pmpm_to_pepy(company_a.claims, company_a.enrollment)
    b_result = convert_pmpm_to_pepy(company_b.claims, company_b.enrollment)
    
    return {
        'company_a': {
            'pmpm': a_result['pmpm'],
            'pepy': a_result['pepy'],
            'lives_per_employee': a_result['avg_lives_per_employee']
        },
        'company_b': {
            'pmpm': b_result['pmpm'],
            'pepy': b_result['pepy'],
            'lives_per_employee': b_result['avg_lives_per_employee']
        },
        'variance': {
            'pmpm_diff': ((b_result['pmpm'] / a_result['pmpm']) - 1) * 100,
            'pepy_diff': ((b_result['pepy'] / a_result['pepy']) - 1) * 100
        }
    }

# Example Output:
# Company A (Tech, 75% single coverage):
#   PMPM: $420
#   Avg Lives/Employee: 1.4
#   PEPY: $7,056
# 
# Company B (Manufacturing, 60% family coverage):
#   PMPM: $485 (+15.5% vs. A)
#   Avg Lives/Employee: 2.6
#   PEPY: $15,132 (+114% vs. A)
# 
# Interpretation: Company B's PMPM looks 15% higher, but PEPY is 114% higher
# due to much higher dependent coverage. True cost per employee is far worse.