capacity-planning-helper

Capacity Planning Helper

Right-size infrastructure for current and future needs.

Traffic Forecasting

interface TrafficForecast {
  current: {
    dailyUsers: number;
    peakRPS: number;
    avgRPS: number;
  };
  projected: {
    timeframe: "6m" | "12m" | "24m";
    dailyUsers: number;
    peakRPS: number;
    avgRPS: number;
    growthRate: number;
  };
}

const forecast: TrafficForecast = {
  current: {
    dailyUsers: 100000,
    peakRPS: 500,
    avgRPS: 200,
  },
  projected: {
    timeframe: "12m",
    dailyUsers: 500000, // 5x growth
    peakRPS: 2500,
    avgRPS: 1000,
    growthRate: 4.0, // 400% growth
  },
};

Resource Estimation

interface ResourceNeeds {
  compute: {
    instanceType: string;
    instanceCount: number;
    cpu: number;
    memory: number;
  };
  database: {
    instanceType: string;
    instanceCount: number;
    storage: number;
    iops: number;
  };
  cache: {
    instanceType: string;
    nodes: number;
    memory: number;
  };
}

function estimateResources(forecast: TrafficForecast): ResourceNeeds {
  const { peakRPS } = forecast.projected;

  // Rule of thumb: 100 RPS per instance (with headroom)
  const instanceCount = Math.ceil(peakRPS / 100);

  // Database: 1000 connections per 2vCPU
  const dbInstances = Math.ceil((peakRPS * 2) / 1000);

  return {
    compute: {
      instanceType: "t3.large",
      instanceCount: instanceCount * 1.5, // 50% headroom
      cpu: 2 * instanceCount,
      memory: 8 * instanceCount,
    },
    database: {
      instanceType: "db.r6g.xlarge",
      instanceCount: dbInstances,
      storage: 1000, // GB
      iops: 10000,
    },
    cache: {
      instanceType: "cache.r6g.large",
      nodes: 2, // Primary + replica
      memory: 12, // GB
    },
  };
}

Cost Estimation

interface CostEstimate {
  monthly: {
    compute: number;
    database: number;
    cache: number;
    storage: number;
    bandwidth: number;
    total: number;
  };
  annual: number;
}

const pricing = {
  "t3.large": 0.0832, // $/hour
  "db.r6g.xlarge": 0.336,
  "cache.r6g.large": 0.226,
  storage: 0.1, // $/GB/month
  bandwidth: 0.09, // $/GB
};

function estimateCost(
  resources: ResourceNeeds,
  trafficGB: number
): CostEstimate {
  const hoursPerMonth = 730;

  const monthly = {
    compute:
      resources.compute.instanceCount * pricing["t3.large"] * hoursPerMonth,
    database:
      resources.database.instanceCount *
      pricing["db.r6g.xlarge"] *
      hoursPerMonth,
    cache: resources.cache.nodes * pricing["cache.r6g.large"] * hoursPerMonth,
    storage: resources.database.storage * pricing.storage,
    bandwidth: trafficGB * pricing.bandwidth,
    total: 0,
  };

  monthly.total = Object.values(monthly).reduce((sum, cost) => sum + cost, 0);

  return {
    monthly,
    annual: monthly.total * 12,
  };
}