Value Engineering#

Benefits − Costs = Net Value
Net Value / Costs = ROI
Initial Investment / Annual Net Value = Payback Period

from dataclasses import dataclass
from typing import Optional

@dataclass
class AIDevelopmentCosts:
    """One-time costs for initial deployment."""
    poc_fde_hours: float              # FDE hours during POC
    poc_client_engineering_hours: float
    production_engineering_hours: float
    integration_testing_hours: float
    clinical_validation_hours: float  # Physician time for evaluation
    security_review_hours: float
    training_and_change_management: float
    
    hourly_rate_fde: float            # *(illustrative — verify current rates)*
    hourly_rate_client_engineer: float
    hourly_rate_physician: float
    
    def total_one_time_cost(self) -> float:
        fde_cost = (self.poc_fde_hours + self.production_engineering_hours) * self.hourly_rate_fde
        client_eng_cost = (self.poc_client_engineering_hours + self.integration_testing_hours) * self.hourly_rate_client_engineer
        clinical_cost = self.clinical_validation_hours * self.hourly_rate_physician
        other = self.security_review_hours * self.hourly_rate_client_engineer + self.training_and_change_management
        return fde_cost + client_eng_cost + clinical_cost + other


@dataclass
class AIOperationalCosts:
    """Annual recurring costs."""
    llm_api_cost_annual: float        # Token costs at projected volume *(illustrative)*
    ai_gateway_hosting: float         # Cloud infrastructure
    vector_store_hosting: float       # If clinical RAG is included
    embedding_model_cost: float       # If separate from LLM cost
    internal_maintenance_hours: float # Client engineering maintenance
    clinical_monitoring_hours: float  # Physician oversight / evaluation
    
    hourly_rate_client_engineer: float
    hourly_rate_physician: float
    
    def total_annual_cost(self) -> float:
        infra = self.llm_api_cost_annual + self.ai_gateway_hosting + self.vector_store_hosting + self.embedding_model_cost
        labor = (self.internal_maintenance_hours * self.hourly_rate_client_engineer +
                 self.clinical_monitoring_hours * self.hourly_rate_physician)
        return infra + labor


def calculate_total_cost_of_ownership(
    dev: AIDevelopmentCosts,
    ops: AIOperationalCosts,
    years: int = 3
) -> dict:
    """Calculate 3-year total cost of ownership."""
    one_time = dev.total_one_time_cost()
    annual = ops.total_annual_cost()
    return {
        "one_time_cost": one_time,
        "annual_cost": annual,
        "total_3yr": one_time + (annual * years),
        "year_1_total": one_time + annual,
        "year_2_total": annual,
        "year_3_total": annual,
    }

@dataclass
class TimeSavingsBenefit:
    """Physician or staff time recaptured by AI automation."""
    
    # Use case parameters
    use_case: str                          # "Discharge Summary AI"
    beneficiary_role: str                  # "Hospitalist physician"
    current_time_per_unit_minutes: float   # Minutes per discharge summary currently
    ai_assisted_time_per_unit_minutes: float  # Estimated with AI assist
    
    # Volume
    annual_volume: int                     # Annual discharges (or equivalent)
    adoption_rate_year_1: float = 0.5     # Conservative: 50% of encounters use AI in Year 1
    adoption_rate_steady_state: float = 0.85  # 85% at steady state
    
    # Cost parameters *(illustrative — verify current physician compensation data)*
    fully_loaded_hourly_rate: float = 180.0  # Physician fully loaded cost/hour
    
    def time_saved_per_unit_minutes(self) -> float:
        return self.current_time_per_unit_minutes - self.ai_assisted_time_per_unit_minutes
    
    def annual_hours_saved(self, adoption_rate: float) -> float:
        units_using_ai = self.annual_volume * adoption_rate
        minutes_saved = units_using_ai * self.time_saved_per_unit_minutes()
        return minutes_saved / 60
    
    def annual_value(self, year: int = 1) -> float:
        rate = self.adoption_rate_year_1 if year == 1 else self.adoption_rate_steady_state
        return self.annual_hours_saved(rate) * self.fully_loaded_hourly_rate


@dataclass
class QualityImprovementBenefit:
    """Benefit from reduction in errors, denials, or readmissions."""
    
    benefit_type: str    # "Readmission reduction" | "Denial reduction" | "Documentation deficiency reduction"
    
    # Readmission example
    annual_discharges: int = 35000
    current_readmission_rate: float = 0.145   # 14.5% (illustrative national average range)
    expected_readmission_rate_reduction: float = 0.005  # 0.5 percentage point improvement
    cms_penalty_per_excess_readmission: float = 0.0    # CMS penalty calculation is complex — use avoided penalty
    average_readmission_cost: float = 14000           # *(illustrative — varies significantly by condition)*
    
    # Deny/appeal reduction example
    annual_prior_auth_submissions: int = 8000
    current_denial_rate: float = 0.18              # 18% denial rate
    expected_denial_rate_reduction: float = 0.03   # 3 percentage point improvement
    cost_to_appeal: float = 120                    # Staff cost per appeal *(illustrative)*
    average_denied_claim_value: float = 2400       # *(illustrative)*
    
    def readmission_reduction_value(self) -> float:
        readmissions_avoided = self.annual_discharges * self.expected_readmission_rate_reduction
        return readmissions_avoided * self.average_readmission_cost
    
    def denial_reduction_value(self) -> float:
        denials_avoided = self.annual_prior_auth_submissions * self.expected_denial_rate_reduction
        return denials_avoided * (self.cost_to_appeal + self.average_denied_claim_value * 0.40)
        # 40% of denied claims are eventually recovered with appeals effort *(illustrative)*

def build_roi_model(
    dev_costs: AIDevelopmentCosts,
    ops_costs: AIOperationalCosts,
    time_benefits: list[TimeSavingsBenefit],
    quality_benefits: list[QualityImprovementBenefit],
    projection_years: int = 3
) -> dict:
    """
    Construct a multi-year ROI model for an AI deployment.
    
    All financial figures are illustrative.
    Verify current physician compensation rates, claim values,
    and readmission costs against authoritative sources for each client.
    """
    tco = calculate_total_cost_of_ownership(dev_costs, ops_costs, projection_years)
    
    annual_benefits = []
    for year in range(1, projection_years + 1):
        time_value = sum(b.annual_value(year) for b in time_benefits)
        quality_value = sum([
            b.readmission_reduction_value() if hasattr(b, 'readmission_reduction_value') else 0
            for b in quality_benefits
        ])
        # Apply ramp factor: Year 1 = 50%, Year 2 = 80%, Year 3+ = 100%
        ramp = {1: 0.5, 2: 0.8}.get(year, 1.0)
        annual_benefits.append(time_value * ramp + quality_value * ramp)
    
    total_benefit_3yr = sum(annual_benefits)
    total_cost_3yr = tco["total_3yr"]
    net_value_3yr = total_benefit_3yr - total_cost_3yr
    roi_3yr = net_value_3yr / total_cost_3yr
    
    # Payback period calculation
    cumulative_net = -tco["one_time_cost"]
    payback_months = None
    for m in range(1, projection_years * 12 + 1):
        month_benefit = annual_benefits[min(m // 12, len(annual_benefits) - 1)] / 12
        month_cost = ops_costs.total_annual_cost() / 12
        cumulative_net += month_benefit - month_cost
        if cumulative_net >= 0 and payback_months is None:
            payback_months = m
    
    return {
        "one_time_investment": tco["one_time_cost"],
        "annual_operating_cost": ops_costs.total_annual_cost(),
        "annual_benefits_year_1": annual_benefits[0],
        "annual_benefits_year_2": annual_benefits[1] if len(annual_benefits) > 1 else None,
        "annual_benefits_year_3": annual_benefits[2] if len(annual_benefits) > 2 else None,
        "total_benefit_3yr": total_benefit_3yr,
        "total_cost_3yr": total_cost_3yr,
        "net_value_3yr": net_value_3yr,
        "roi_3yr_percent": roi_3yr * 100,
        "payback_months": payback_months,
        "note": "All figures are illustrative estimates. Verify cost and benefit assumptions against client-specific data."
    }

KPI_FRAMEWORK = {
    "discharge_summary_ai": {
        "primary_kpi": {
            "metric": "Physician documentation time per discharge",
            "baseline_measurement": "Time-motion study or EHR audit log analysis — 2-week pre-deployment sample",
            "target": "20% reduction in documentation time per encounter",
            "measurement_method": "EHR audit log: time from note open to note signed",
            "measurement_cadence": "Monthly",
            "owner": "Clinical Informatics"
        },
        "secondary_kpis": [
            {
                "metric": "Discharge summary section completeness",
                "baseline": "Manual review of 50 pre-deployment discharge summaries",
                "target": "> 95% completeness on required sections",
                "method": "Automated completeness check against HMS documentation template"
            },
            {
                "metric": "Physician satisfaction score",
                "baseline": "Pre-deployment survey (Likert scale)",
                "target": "> 3.5/5.0",
                "method": "Monthly pulse survey"
            },
            {
                "metric": "Time-to-discharge (from decision to actual)",
                "baseline": "Pre-deployment EHR data, 90-day sample",
                "target": "10% reduction",
                "method": "EHR audit log: discharge order to physical discharge"
            }
        ],
        "financial_kpi": {
            "metric": "Physician hours recovered per quarter",
            "calculation": "Time saved per encounter × encounter volume × adoption rate",
            "reporting_to": "CMO, CFO"
        }
    },
    "prior_auth_ai": {
        "primary_kpi": {
            "metric": "Prior authorization denial rate",
            "baseline": "90-day payer denial rate from RCM system",
            "target": "3 percentage point improvement",
            "method": "Monthly payer denial report from RCM"
        },
        "secondary_kpis": [
            {"metric": "Time from order to auth approval", "target": "20% reduction"},
            {"metric": "Staff hours per authorization", "target": "30% reduction"},
            {"metric": "Clean submission rate", "target": "> 90%"}
        ]
    }
}

# AI Business Case: Discharge Summary Automation
**Reference Healthcare Organization**
*[Prepared by FDE — figures are illustrative estimates based on client-provided data]*

## The Opportunity

Hospitalists at the Reference Healthcare Organization spend approximately [X] minutes
per discharge summary — [Y] hours per day across the hospitalist group. At an
illustrative fully loaded cost of [Z/hour], this represents approximately $[N]M in
annual physician time on a single documentation task.

AI-assisted discharge summary generation reduces documentation time by an estimated
20–30 minutes per encounter, based on published studies in comparable health systems.
*(Verify against current literature and client-specific time-motion data.)*

## Financial Model Summary

| | Year 1 | Year 2 | Year 3 |
|--|--------|--------|--------|
| Investment | $[one-time + Y1 ops] | $[Y2 ops] | $[Y3 ops] |
| Benefit (time savings) | $[Y1 benefit] | $[Y2 benefit] | $[Y3 benefit] |
| Net Value | $[Y1 net] | $[Y2 net] | $[Y3 net] |

**3-Year ROI:** [X]% | **Payback Period:** [N] months

*All figures are illustrative estimates based on client-provided volume data and
published benchmarks. Actual results will vary. Baseline measurement recommended
before deployment.*

## Key Assumptions

- [X] annual inpatient discharges (provided by client)
- [Y] min current documentation time per discharge (to be validated via time-motion study)
- [Z] min AI-assisted documentation time (based on POC evaluation)
- [W]% adoption rate at steady state (based on comparable deployments)
- $[rate]/hour fully loaded physician cost *(illustrative — verify current data)*

## Risk Factors

- Physician adoption rate lower than assumed → Extend champion network
- POC quality metrics not met in production → Prompt re-engineering cycle
- App Orchard review longer than 12 weeks → Delayed Year 1 benefit realization

## Recommended Next Step

[Specific action: "Approve POC execution" or "Proceed to production planning"]