Chapter 8: Insurance Billing & Enterprise Analytics

8.1 Insurance Claims Processing

For digital therapy to achieve widespread adoption and accessibility, integration with insurance reimbursement is essential. The WIA-MENTAL-001 standard specifies automated claims generation and submission workflows compatible with major insurance carriers.

CPT Codes for Digital Therapeutics

Automated Claims Generation

class InsuranceClaimsEngine {
  private clearinghouseAPI: ClearinghouseAPI;
  private codeMapper: CPTCodeMapper;
  
  async generateClaim(
    session: TherapySession,
    patient: Patient,
    provider: Provider
  ): Promise {
    // 1. Determine appropriate CPT code
    const cptCode = this.determineCPTCode(session);
    
    // 2. Verify coverage and eligibility
    const eligibility = await this.verifyEligibility(
      patient.insuranceInfo
    );
    
    if (!eligibility.eligible) {
      throw new Error(`Patient not eligible: ${eligibility.reason}`);
    }
    
    // 3. Build CMS-1500 claim form (electronic)
    const claim = this.buildClaim({
      patient: {
        name: patient.name,
        dob: patient.dob,
        memberId: patient.insuranceInfo.memberId,
        groupNumber: patient.insuranceInfo.groupNumber
      },
      provider: {
        npi: provider.npi,
        name: provider.name,
        taxId: provider.taxId,
        address: provider.address
      },
      service: {
        cptCode: cptCode.code,
        modifier: cptCode.modifier,
        diagnosisCode: this.getICD10Code(session.diagnosis),
        serviceDate: session.date,
        placeOfService: '02', // Telehealth
        chargeAmount: cptCode.standardCharge,
        units: 1
      },
      insurance: {
        payerId: eligibility.payerId,
        planName: patient.insuranceInfo.planName,
        relationshipToPrimary: 'self'
      }
    });
    
    // 4. Validate claim
    const validation = this.validateClaim(claim);
    if (!validation.valid) {
      throw new Error(`Invalid claim: ${validation.errors.join(', ')}`);
    }
    
    // 5. Submit to clearinghouse
    const submission = await this.submitClaim(claim);
    
    // 6. Track claim status
    await this.trackClaim(submission.claimId);
    
    return claim;
  }
  
  private determineCPTCode(session: TherapySession): CPTCode {
    // Map session to appropriate CPT code
    const duration = session.durationMinutes;
    
    if (session.type === 'assessment') {
      return { code: '96127', modifier: null };
    }
    
    // Psychotherapy codes based on duration
    if (duration >= 16 && duration <= 37) {
      return { code: '90832', modifier: 'GT' }; // GT = via telehealth
    } else if (duration >= 38 && duration <= 52) {
      return { code: '90834', modifier: 'GT' };
    } else if (duration >= 53) {
      return { code: '90837', modifier: 'GT' };
    } else {
      throw new Error(`Session duration ${duration} min does not meet CPT requirements`);
    }
  }
  
  private async verifyEligibility(
    insurance: InsuranceInfo
  ): Promise {
    // Real-time eligibility check via ANSI X12 270/271
    const request = {
      memberId: insurance.memberId,
      dob: insurance.dob,
      serviceType: '30', // Behavioral health
      payerId: insurance.payerId
    };
    
    const response = await this.clearinghouseAPI.checkEligibility(request);
    
    return {
      eligible: response.active && response.coversBehavioralHealth,
      payerId: response.payerId,
      planName: response.planName,
      copay: response.copay,
      deductible: response.deductible,
      deductibleMet: response.deductibleMet,
      outOfPocketMax: response.outOfPocketMax,
      reason: response.ineligibilityReason
    };
  }
  
  async trackClaimStatus(claimId: string): Promise {
    // Check claim status via ANSI X12 276/277
    const status = await this.clearinghouseAPI.getClaimStatus(claimId);
    
    return {
      claimId,
      status: status.code, // 1=Accepted, 2=Rejected, 3=Pending, etc.
      paymentAmount: status.paymentAmount,
      patientResponsibility: status.patientResponsibility,
      adjustmentReasons: status.adjustmentReasons,
      eobDate: status.eobDate
    };
  }
}

8.2 Revenue Cycle Management

Effective revenue cycle management ensures financial sustainability while maintaining focus on patient care. Automation of billing, collections, and reporting reduces administrative burden.

Revenue Cycle Workflow

8.3 Enterprise Analytics Dashboard

Healthcare organizations require comprehensive analytics to demonstrate value, optimize operations, and improve outcomes. Enterprise dashboards provide insights across clinical, operational, and financial dimensions.

Key Performance Indicators

Analytics Implementation

class EnterpriseAnalyticsDashboard {
  private metricsEngine: MetricsEngine;
  private dataWarehouse: DataWarehouse;
  
  async generateExecutiveDashboard(
    organizationId: string,
    dateRange: DateRange
  ): Promise {
    // Parallel data aggregation
    const [clinical, operational, financial] = await Promise.all([
      this.getClinicalMetrics(organizationId, dateRange),
      this.getOperationalMetrics(organizationId, dateRange),
      this.getFinancialMetrics(organizationId, dateRange)
    ]);
    
    return {
      summary: {
        totalPatients: operational.totalPatients,
        activePatients: operational.activePatients,
        completedSessions: operational.totalSessions,
        revenue: financial.totalRevenue
      },
      clinical: {
        outcomeMetrics: {
          phq9Reduction: clinical.averagePHQ9Reduction,
          remissionRate: clinical.remissionRate,
          completionRate: clinical.completionRate,
          timeToResponse: clinical.avgTimeToResponse
        },
        comparisonToBaseline: clinical.baselineComparison,
        trendData: clinical.monthlyTrends
      },
      operational: {
        engagement: {
          dau: operational.dailyActiveUsers,
          sessionDuration: operational.avgSessionDuration,
          retentionRate: operational.retentionRate
        },
        capacity: {
          therapistUtilization: operational.therapistUtilization,
          averageCaseload: operational.avgCaseload,
          maxCapacity: operational.maxCapacity
        },
        performance: {
          uptime: operational.systemUptime,
          responseTime: operational.avgResponseTime,
          errorRate: operational.errorRate
        }
      },
      financial: {
        revenue: {
          total: financial.totalRevenue,
          byPayerType: financial.revenueByPayer,
          trend: financial.monthlyRevenueTrend
        },
        receivables: {
          daysInAR: financial.daysInAR,
          collectionRate: financial.collectionRate,
          agingBuckets: financial.arAgingBuckets
        },
        efficiency: {
          costPerPatient: financial.costPerPatient,
          reimbursementRate: financial.avgReimbursement,
          profitMargin: financial.profitMargin
        }
      }
    };
  }
  
  private async getClinicalMetrics(
    orgId: string,
    dateRange: DateRange
  ): Promise {
    const query = `
      WITH baseline AS (
        SELECT 
          patient_id,
          MIN(total_score) as baseline_score,
          MIN(timestamp) as baseline_date
        FROM clinical_assessments
        WHERE assessment_type = 'PHQ-9'
          AND organization_id = $1
        GROUP BY patient_id
      ),
      followup AS (
        SELECT 
          patient_id,
          total_score as followup_score,
          timestamp as followup_date
        FROM clinical_assessments
        WHERE assessment_type = 'PHQ-9'
          AND organization_id = $1
          AND timestamp BETWEEN $2 AND $3
      )
      SELECT 
        COUNT(*) as total_patients,
        AVG((b.baseline_score - f.followup_score) / b.baseline_score * 100) as avg_reduction,
        SUM(CASE WHEN f.followup_score < 5 THEN 1 ELSE 0 END)::FLOAT / COUNT(*) as remission_rate,
        AVG(EXTRACT(EPOCH FROM (f.followup_date - b.baseline_date)) / 604800) as avg_weeks_to_response
      FROM baseline b
      JOIN followup f ON b.patient_id = f.patient_id
    `;
    
    const result = await this.dataWarehouse.query(query, [
      orgId,
      dateRange.start,
      dateRange.end
    ]);
    
    return result.rows[0];
  }
}

8.4 Future Roadmap

The WIA-MENTAL-001 standard continues to evolve. Future enhancements will expand capabilities while maintaining core principles of evidence-based care, patient privacy, and accessibility.

Emerging Technologies