n.

Core Solution

Building a reliable TCO projection requires decoupling usage simulation from billing logic. Static spreadsheets fail because they assume flat consumption. Real AI workloads exhibit token inflation, resolution rate maturation, and tier threshold breaches. The following TypeScript implementation uses the Strategy pattern to model each pricing model as a swappable adapter, enabling accurate 36-month curve simulation.

Step 1: Define Usage Profile and Projection Interfaces

export interface UsageProfile {
  initialVolume: number;
  monthlyGrowthRate: number;
  resolutionRate: number;
  tokenInflationFactor: number;
  projectionMonths: number;
}

export interface ProjectionResult {
  model: string;
  monthlyCosts: number[];
  cumulativeCost: number;
  inflectionPointMonth: number | null;
}

Step 2: Implement Pricing Strategy Adapters

Each adapter encapsulates the mathematical rules for a specific billing model. This isolates commercial logic from simulation mechanics.

interface PricingStrategy {
  calculateMonthlyCost(volume: number, resolutionRate: number, tokensPerUnit: number): number;
}

class PerSeatStrategy implements PricingStrategy {
  private readonly costPerSeat: number;
  private readonly seatCount: number;

  constructor(costPerSeat: number, seatCount: number) {
    this.costPerSeat = costPerSeat;
    this.seatCount = seatCount;
  }

  calculateMonthlyCost(): number {
    return this.costPerSeat * this.seatCount;
  }
}

class PerTokenStrategy implements PricingStrategy {
  private readonly costPerThousandTokens: number;

  constructor(costPerThousandTokens: number) {
    this.costPerThousandTokens = costPerThousandTokens;
  }

  calculateMonthlyCost(_volume: number, _resolutionRate: number, tokensPerUnit: number): number {
    const totalTokens = _volume * tokensPerUnit;
    return (totalTokens / 1000) * this.costPerThousandTokens;
  }
}

class PerResolutionStrategy implements PricingStrategy {
  private readonly costPerResolved: number;

  constructor(costPerResolved: number) {
    this.costPerResolved = costPerResolved;
  }

  calculateMonthlyCost(volume: number, resolutionRate: number): number {
    const resolvedCount = Math.floor(volume * resolutionRate);
    return resolvedCount * this.costPerResolved;
  }
}

class HybridStrategy implements PricingStrategy {
  private readonly baseFee: number;
  private readonly includedVolume: number;
  private readonly overageRate: number;

  constructor(baseFee: number, includedVolume: number, overageRate: number) {
    this.baseFee = baseFee;
    this.includedVolume = includedVolume;
    this.overageRate = overageRate;
  }

  calculateMonthlyCost(volume: number): number {
    if (volume <= this.includedVolume) return this.baseFee;
    const overageUnits = volume - this.includedVolume;
    return this.baseFee + (overageUnits * this.overageRate);
  }
}

class CapexStrategy implements PricingStrategy {
  private readonly buildCost: number;
  private readonly monthlyComputeCost: number;

  constructor(buildCost: number, monthlyComputeCost: number) {
    this.buildCost = buildCost;
    this.monthlyComputeCost = monthlyComputeCost;
  }

  calculateMonthlyCost(): number {
    return this.monthlyComputeCost;
  }

  getInitialCost(): number {
    return this.buildCost;
  }
}

Step 3: Build the Projection Engine

The engine simulates month-by-month growth, applies token inflation, tracks resolution rate maturation, and identifies the inflection point where one model becomes cheaper than another.

export class CostCurveSimulator {
  private strategies: Record<string, PricingStrategy>;

  constructor(strategies: Record<string, PricingStrategy>) {
    this.strategies = strategies;
  }

  simulate(profile: UsageProfile): Record<string, ProjectionResult> {
    const results: Record<string, ProjectionResult> = {};
    let currentVolume = profile.initialVolume;
    let currentResolutionRate = profile.resolutionRate;

    for (const [name, strategy] of Object.entries(this.strategies)) {
      const monthlyCosts: number[] = [];
      let cumulative = 0;
      let inflectionMonth: number | null = null;

      for (let month = 0; month < profile.projectionMonths; month++) {
        const tokensPerUnit = 1000 * (1 + profile.tokenInflationFactor * month);
        let cost = 0;

        if (strategy instanceof PerSeatStrategy) {
          cost = strategy.calculateMonthlyCost();
        } else if (strategy instanceof PerTokenStrategy) {
          cost = strategy.calculateMonthlyCost(currentVolume, currentResolutionRate, tokensPerUnit);
        } else if (strategy instanceof PerResolutionStrategy) {
          cost = strategy.calculateMonthlyCost(currentVolume, currentResolutionRate);
        } else if (strategy instanceof HybridStrategy) {
          cost = strategy.calculateMonthlyCost(currentVolume);
        } else if (strategy instanceof CapexStrategy) {
          cost = month === 0 
            ? strategy.calculateMonthlyCost() + strategy.getInitialCost() 
            : strategy.calculateMonthlyCost();
        }

        monthlyCosts.push(cost);
        cumulative += cost;

        if (inflectionMonth === null && cumulative > 150000) {
          inflectionMonth = month + 1;
        }
      }

      results[name] = {
        model: name,
        monthlyCosts,
        cumulativeCost: cumulative,
        inflectionPointMonth: inflectionMonth
      };

      currentVolume *= (1 + profile.monthlyGrowthRate);
      currentResolutionRate = Math.min(0.95, currentResolutionRate + 0.005);
    }

    return results;
  }
}

Architecture Decisions and Rationale

1. Strategy Pattern over Conditional Logic: Pricing models evolve. Vendors introduce new tiers, adjust overage multipliers, or shift from per-ticket to per-resolution. Encapsulating each model in a dedicated class prevents conditional sprawl and enables unit testing of commercial logic in isolation.
2. Simulation over Static Calculation: AI usage is rarely linear. Token inflation occurs as prompts grow more complex. Resolution rates improve as models fine-tune on historical data. Volume compounds with product adoption. A month-by-month simulation captures these dynamics, whereas static formulas produce misleading averages.
3. Inflection Point Tracking: The inflectionPointMonth field identifies when cumulative costs breach a configurable threshold. This enables engineering teams to trigger architectural reviews, negotiate enterprise contracts, or migrate to capex deployments before budget overruns occur.
4. Type Safety for Commercial Parameters: Using explicit interfaces for UsageProfile and ProjectionResult prevents runtime type mismatches when integrating with finance dashboards or CI/CD cost gates.

Pitfall Guide

1. The Overage Multiplier Trap

Explanation: Hybrid models often charge 2–3× the in-tier rate for overage units. Engineering teams budget for the base tier but ignore the penalty structure, leading to sudden invoice spikes when usage crosses the threshold. Fix: Model overage rates as a separate variable in your simulation. Implement automated usage alerts at 80% and 95% of tier capacity. Negotiate overage caps or tier-rollover credits in vendor contracts.

2. Outcome Definition Ambiguity

Explanation: Per-resolution billing relies on contractual definitions of "resolved." Vendors may count a conversation as resolved if the AI responds, even if the user follows up with a human agent. This creates false-positive billing. Fix: Instrument resolution tracking at the application layer, not the vendor layer. Require contract clauses that define resolution as "no human escalation within 48 hours" or "positive user sentiment score." Audit resolution logs monthly.

3. Token Inflation Blind Spot

Explanation: Teams assume token consumption remains constant. In practice, prompt templates grow, context windows expand, and retry loops increase token volume by 15–30% over six months. Per-token models silently compound costs. Fix: Implement token budgeting middleware that strips unnecessary context, caches repeated system prompts, and enforces max token limits per request. Track tokens per successful outcome, not just raw volume.

4. Capex Maintenance Neglect

Explanation: Bespoke deployments eliminate recurring licensing but shift costs to infrastructure, model hosting, and engineering maintenance. Teams underestimate the 15–20% annual overhead required for updates, security patches, and model versioning. Fix: Factor a 1.15–1.20 multiplier into capex projections for years 2 and 3. Establish a dedicated platform engineering squad for AI workflow maintenance. Use infrastructure-as-code to track compute drift.

5. Tier-Cliff Budgeting

Explanation: Hybrid models create step functions where costs remain flat until a threshold, then jump. Finance teams approve budgets based on the flat period, causing cash flow shocks when volume crosses the boundary. Fix: Model tier boundaries as hard constraints in capacity planning. Pre-purchase tier upgrades during low-usage periods. Implement dynamic routing that queues requests during peak hours to smooth volume spikes.

6. Ignoring Workflow Volatility

Explanation: Not all AI workloads scale predictably. Seasonal campaigns, marketing pushes, or incident response workflows cause volume spikes that break linear pricing assumptions. Fix: Classify workflows as steady-state or burst-driven. Apply hybrid or capex models to steady-state pipelines. Use per-token or reserved capacity pools for burst scenarios. Implement circuit breakers that degrade gracefully during spikes.

7. Vendor Lock-in via Pricing Architecture

Explanation: Vendors design pricing models that increase switching costs. Per-token models embed proprietary tokenization. Outcome-based models require proprietary tracking SDKs. Migration becomes financially punitive. Fix: Abstract vendor APIs behind a unified billing interface. Maintain a fallback routing layer that can switch providers without rewriting core logic. Negotiate data export clauses and model-agnostic contract terms.

Production Bundle

Action Checklist

• Map all AI workflows to their billing model and extract commercial terms from vendor contracts
• Instrument token consumption, resolution rates, and volume growth in production monitoring
• Build a simulation engine using the strategy pattern to project 36-month TCO
• Define contractual resolution criteria with explicit false-positive handling clauses
• Implement automated tier-capacity alerts at 80% and 95% utilization thresholds
• Establish a monthly pricing review cadence with engineering and finance stakeholders
• Negotiate overage caps, tier-rollover credits, and data export rights before signing
• Classify workflows as steady-state or burst-driven to align with appropriate cost shapes

Decision Matrix

Scenario	Recommended Approach	Why	Cost Impact
Steady-state support pipeline with predictable volume	Hybrid (base + overage)	Provides budget floor with elasticity for growth	Low volatility, predictable step function
High-volume API integration with prompt optimization	Per-Token with caching layer	Aligns cost with actual compute consumption	Linear but controllable via token reduction
Resolution-driven workflow with maturing AI accuracy	Per-Resolution	Vendors only paid for successful outcomes	Sub-linear as resolution rate improves
50+ active workflows or strict compliance requirements	Bespoke/Capex	Eliminates recurring licensing drag at scale	High upfront, low marginal cost long-term
Experimental or seasonal burst workloads	Per-Ticket or Reserved Capacity	Avoids long-term commitment during volatility	Predictable per-unit cost during spikes

Configuration Template

// pricing-config.ts
import { UsageProfile } from './cost-simulator';

export const defaultUsageProfile: UsageProfile = {
  initialVolume: 5000,
  monthlyGrowthRate: 0.08,
  resolutionRate: 0.70,
  tokenInflationFactor: 0.02,
  projectionMonths: 36
};

export const vendorPricing = {
  perSeat: { costPerSeat: 120, seatCount: 15 },
  perToken: { costPerThousandTokens: 0.005 },
  perResolution: { costPerResolved: 0.99 },
  hybrid: { baseFee: 2000, includedVolume: 8000, overageRate: 0.45 },
  capex: { buildCost: 30000, monthlyComputeCost: 2500 }
};

export const alertThresholds = {
  tierUtilization: [0.80, 0.95],
  monthlyBudgetCap: 15000,
  resolutionRateFloor: 0.65
};

Quick Start Guide

1. Extract Commercial Terms: Pull pricing tables, overage multipliers, and resolution definitions from vendor contracts. Map each to the corresponding strategy class.
2. Initialize Simulation: Import the configuration template, instantiate each pricing strategy, and pass them to CostCurveSimulator. Run the 36-month projection against your defaultUsageProfile.
3. Instrument Production Metrics: Deploy token tracking, resolution logging, and volume counters to your AI workflow endpoints. Feed real telemetry into the simulation monthly to validate projections.
4. Set Budget Gates: Configure alerts at 80% tier utilization and monthly budget caps. Route overage requests to a fallback provider or queue system when thresholds are breached.
5. Review Quarterly: Compare simulated curves against actual invoices. Adjust growth rates, resolution targets, and overage assumptions. Renegotiate contracts or migrate to capex when inflection points are reached.