ri-optimizer-policy.yaml

rdcoded Logic:** Coverage targets, instance family flexibility, and account routing rules are externalized to configuration. This allows finance and engineering to adjust parameters without code deployments. 3. Forecasting via Exponential Smoothing: Simple moving averages fail to capture workload seasonality. Exponential smoothing with trend damping provides lightweight, production-ready forecasts without ML overhead. 4. Dry-Run Execution Mode: All purchase or modification recommendations pass through a simulation layer that validates cost impact, coverage delta, and expiration alignment before API calls are executed. 5. Stateful Coverage Ledger: A persistent record of active commitments, utilization rates, and expiration dates enables drift detection and automated renewal scheduling.

Step-by-Step Implementation

Step 1: Ingest and Normalize Usage Data

Pull hourly or daily instance-hour consumption, group by account, region, instance family, and OS. Filter out bursty or ephemeral workloads using a utilization threshold (e.g., <40% average weekly usage).

Step 2: Forecast Steady-State Demand

Apply exponential smoothing to normalized usage. Calculate a baseline coverage target (typically 70–80% of forecasted steady-state hours).

Step 3: Match to Commitment Offerings

Compare forecasted demand against available RI/Savings Plan catalogs. Prioritize instance family flexibility, regional sharing rules, and term length (1-year vs 3-year) based on policy configuration.

Step 4: Execute and Monitor

Generate purchase recommendations, run dry-run validation, execute via cloud APIs, and update the coverage ledger. Schedule weekly drift audits and expiration alerts.

TypeScript Implementation

The following module demonstrates the core optimization logic: utilization analysis, coverage targeting, and recommendation generation.

import { S3Client, GetObjectCommand } from "@aws-sdk/client-s3";
import { CostExplorerClient, GetReservationUtilizationCommand } from "@aws-sdk/client-cost-explorer";

interface UsageRecord {
  instanceFamily: string;
  region: string;
  account: string;
  hours: number;
  utilization: number; // 0-1
}

interface RIRecommendation {
  instanceFamily: string;
  region: string;
  account: string;
  targetHours: number;
  term: "1yr" | "3yr";
  payment: "noUpfront" | "partialUpfront" | "allUpfront";
  expectedSavings: number;
}

class RIOptimizer {
  private coverageTarget: number = 0.75;
  private minUtilizationThreshold: number = 0.4;
  private smoothingAlpha: number = 0.3;
  private smoothingBeta: number = 0.1;

  constructor(
    private costExplorer: CostExplorerClient,
    private s3: S3Client
  ) {}

  /**
   * Analyze historical usage and filter for steady-state workloads
   */
  async analyzeUsage(billingBucket: string, keyPrefix: string): Promise<UsageRecord[]> {
    const response = await this.s3.send(new GetObjectCommand({ Bucket: billingBucket, Key: `${keyPrefix}usage.json` }));
    const raw = JSON.parse(await response.Body?.transformToString() ?? "[]") as UsageRecord[];
    
    return raw
      .filter(r => r.utilization >= this.minUtilizationThreshold)
      .map(r => ({ ...r, hours: Math.round(r.hours * r.utilization) }));
  }

  /**
   * Forecast steady-state hours using double exponential smoothing
   */
  forecastSteadyState(history: number[]): number {
    let level = history[0];
    let trend = history[1] - history[0];
    
    for (let i = 1; i < history.length; i++) {
      const prevLevel = level;
      level = this.smoothingAlpha * history[i] + (1 - this.smoothingAlpha) * (prevLevel + trend);
      trend = this.smoothingBeta * (level - prevLevel) + (1 - this.smoothingBeta) * trend;
    }
    
    return Math.round(level + trend);
  }

  /**
   * Generate RI recommendations based on coverage target and policy
   */
  generateRecommendations(usage: UsageRecord[]): RIRecommendation[] {
    const recommendations: RIRecommendation[] = [];
    const grouped = new Map<string, number[]>();

    usage.forEach(r => {
      const key = `${r.account}|${r.region}|${r.instanceFamily}`;
      if (!grouped.has(key)) grouped.set(key, []);
      grouped.get(key)!.push(r.hours);
    });

    for (const [key, hoursHistory] of grouped.entries()) {
      const [account, region, instanceFamily] = key.split("|");
      const forecasted = this.forecastSteadyState(hoursHistory);
      const targetHours = Math.round(forecasted * this.coverageTarget);

      if (targetHours < 100) continue; // Skip micro-commitments

      recommendations.push({
        instanceFamily,
        region,
        account,
        targetHours,
        term: forecasted > 500 ? "3yr" : "1yr",
        payment: "noUpfront",
        expectedSavings: Math.round(targetHours * 0.35) // Simplified savings model
      });
    }

    return recommendations;
  }

  /**
   * Validate recommendations against coverage drift and expiration windows
   */
  validateRecommendations(recommendations: RIRecommendation[]): boolean {
    const totalTargetHours = recommendations.reduce((sum, r) => sum + r.targetHours, 0);
    const budgetCap = 50000; // Monthly committed spend limit
    
    if (totalTargetHours > budgetCap) {
      console.warn(`[RIOptimizer] Exceeds monthly commitment budget: ${totalTargetHours}`);
      return false;
    }

    return recommendations.every(r => r.targetHours > 0);
  }
}

export { RIOptimizer, RIRecommendation };

The optimizer isolates forecasting, policy application, and validation. Production deployments replace the simplified savings model with cloud API rate cards, integrate AWS Cost Explorer or GCP Billing Export streams, and route recommendations through an approval workflow before execution.

Pitfall Guide

1. Committing to Volatile Workloads RIs require predictable, steady-state usage. Applying commitments to auto-scaled, batch, or dev/test environments guarantees underutilization. Filter workloads using a minimum weekly utilization threshold before including them in coverage calculations.

2. Ignoring Instance Family Flexibility Cloud providers allow commitment pooling across families within a region. Hardcoding exact instance types wastes capacity when workloads shift. Configure policies to target family-level or region-level flexibility where available.

3. Spreadsheet-Driven Lifecycle Management Manual tracking cannot handle expiration sequencing, multi-account sharing, or utilization drift. Implement a coverage ledger with automated alerts 30, 60, and 90 days before commitment expiration.

4. Over-Indexing on 3-Year Terms Without Exit Strategy Longer terms increase discounts but reduce agility. Use 3-year commitments only for core infrastructure with stable demand. Pair shorter terms with modification allowances to maintain adjustment capability.

5. Neglecting Multi-Account Sharing Rules Commitments applied to a single account leave sister accounts paying on-demand rates. Route flexible commitments to a management account or shared pool to maximize cross-account utilization.

6. Failing to Right-Size Before Committing Over-provisioned instances inflate commitment costs. Run right-sizing audits, downsize underutilized resources, then calculate coverage against optimized baselines.

7. Pursuing 100% Coverage Targeting full coverage forces over-provisioning and eliminates fallback options. Maintain 70–80% baseline coverage with on-demand or spot capacity handling burst and seasonal variance.

Best Practices from Production:

• Automate weekly utilization audits and monthly coverage reconciliation
• Decouple procurement cycles from deployment pipelines
• Use policy-as-code to enforce coverage targets, payment terms, and expiration windows
• Integrate cost anomaly detection to flag sudden utilization drops post-commitment
• Maintain a dry-run mode for all purchase and modification operations

Production Bundle

Action Checklist

• Audit current RI/Savings Plan inventory and map utilization rates per account and region
• Right-size underutilized instances and recalculate steady-state baselines
• Configure coverage targets (70–80%) and instance family flexibility policies
• Deploy automated utilization ingestion and exponential smoothing forecast engine
• Implement expiration alerting (30/60/90-day windows) and renewal automation
• Route flexible commitments to shared pools or management accounts
• Run monthly drift reconciliation and adjust recommendations based on actual usage
• Maintain dry-run validation before executing any purchase or modification API calls

Decision Matrix

Scenario	Recommended Approach	Why	Cost Impact
Stable production workloads with predictable traffic	1-year or 3-year RIs with partial upfront	Predictable demand justifies longer terms; partial upfront preserves cash flow	30–45% unit cost reduction
Multi-account organization with shared services	Region-level flexible RIs or Savings Plans pooled at management account	Cross-account sharing maximizes utilization and eliminates siloed waste	15–25% overhead reduction vs per-account purchases
Seasonal or batch processing workloads	On-demand + spot with targeted 1-year RIs for baseline only	Avoids commitment waste during off-peak; spot handles burst variance	40–60% savings on burst capacity; baseline remains stable
Rapidly scaling startup with evolving architecture	Savings Plans with 1-year no-upfront + monthly right-sizing audits	Maintains flexibility while capturing baseline discounts; easy to adjust	20–30% savings with minimal operational friction

Configuration Template

# ri-optimizer-policy.yaml
coverage:
  target_percentage: 0.75
  min_utilization_threshold: 0.4
  max_commitment_budget_monthly: 50000

forecasting:
  method: exponential_smoothing
  smoothing_alpha: 0.3
  smoothing_beta: 0.1
  lookback_days: 90

commitment_rules:
  prefer_flexibility: true
  allowed_terms: ["1yr", "3yr"]
  payment_preference: "noUpfront"
  min_target_hours: 100
  expiration_alert_days: [30, 60, 90]

account_routing:
  shared_pool_accounts:
    - "management-account-id"
    - "shared-services-account-id"
  exclude_patterns:
    - "dev-*"
    - "test-*"
    - "sandbox-*"

execution:
  dry_run_enabled: true
  approval_workflow: true
  api_rate_limit_per_hour: 100
  log_level: "info"

Quick Start Guide

1. Connect Billing & Usage APIs: Configure cloud provider credentials with read access to Cost Explorer/Billing Exports and write access to RI/Savings Plan endpoints. Verify data pipeline connectivity.
2. Run Utilization Audit: Execute the optimizer's analyzeUsage() method against your billing export. Review filtered steady-state workloads and validate utilization thresholds.
3. Generate Recommendations: Run generateRecommendations() with your policy configuration. Inspect output for coverage targets, term selection, and expected savings.
4. Execute Dry-Run: Enable dry_run_enabled: true in the configuration. Validate cost impact, coverage delta, and expiration alignment. Confirm no budget overruns or policy violations.
5. Apply & Monitor: Approve recommendations, execute purchase/modification APIs, and update your coverage ledger. Schedule weekly drift audits and configure expiration alerts. Track effective savings monthly against baseline.