Find Unused Lambda Provisioned Concurrency

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "ReadProvisionedConcurrency",
      "Effect": "Allow",
      "Action": [
        "lambda:ListFunctions",
        "lambda:ListProvisionedConcurrencyConfigs",
        "application-autoscaling:DescribeScalableTargets",
        "cloudwatch:ListMetrics",
        "cloudwatch:GetMetricData"
      ],
      "Resource": "*"
    },
    {
      "Sid": "DeleteIdleConfigsWithApply",
      "Effect": "Allow",
      "Action": "lambda:DeleteProvisionedConcurrencyConfig",
      "Resource": [
        "arn:aws:lambda:*:123456789012:function:*",
        "arn:aws:lambda:*:123456789012:function:*:*"
      ]
    }
  ]
}

// find-unused-lambda-provisioned-concurrency.ts
// Lists every Lambda provisioned concurrency config (per alias or version) with its peak utilization over
// the last N days and its idle monthly charge, and suggests a smaller setting for over-provisioned ones.
// Report only by default. --apply deletes configs with no provisioned invocations in the window, unless
// Application Auto Scaling manages them.
// Usage: npx tsx find-unused-lambda-provisioned-concurrency.ts [--regions us-east-1] [--days 14] [--low 0.3] [--csv pc.csv] [--apply]
import { writeFileSync } from "node:fs";
import {
  DeleteProvisionedConcurrencyConfigCommand,
  LambdaClient,
  paginateListFunctions,
  paginateListProvisionedConcurrencyConfigs,
  type FunctionConfiguration,
} from "@aws-sdk/client-lambda";
import { ApplicationAutoScalingClient, paginateDescribeScalableTargets } from "@aws-sdk/client-application-auto-scaling";
import { CloudWatchClient, paginateGetMetricData, paginateListMetrics, type Dimension } from "@aws-sdk/client-cloudwatch";

const args = process.argv.slice(2);
const flag = (name: string): string | undefined => {
  const i = args.indexOf(name);
  return i >= 0 ? args[i + 1] : undefined;
};
const regions = (flag("--regions") ?? process.env.AWS_REGION ?? "us-east-1").split(",").map((r) => r.trim()).filter(Boolean);
const days = Number(flag("--days") ?? 14);
const low = Number(flag("--low") ?? 0.3); // peak utilization below this is over-provisioned
const csvPath = flag("--csv");
const apply = args.includes("--apply");

// us-east-1 USD per GB-second of provisioned concurrency while it's enabled. AWS Price List (AWSLambda), published 19 September 2026.
const PC_GB_SECOND = { x86_64: 0.0000041667, arm64: 0.0000033334 };
const SECONDS_PER_MONTH = 730 * 3600;

interface Row {
  Region: string;
  Function: string;
  Qualifier: string;
  MemoryMB: number;
  Arch: string;
  Allocated: number;
  Status: string;
  PeakUtil: string;
  PcInvocations: number;
  Spillover: number;
  AutoScaling: string;
  PerMonth: string;
  Verdict: string;
  Action: string;
}

interface Usage {
  peak?: number;
  invocations: number;
  spillover: number;
}

/** Finds the alias/version series via ListMetrics, then reads peak utilization and invocation sums. */
async function usage(cw: CloudWatchClient, fn: string, qualifier: string): Promise<Usage> {
  let dims: Dimension[] | undefined;
  for await (const page of paginateListMetrics({ client: cw }, {
    Namespace: "AWS/Lambda",
    MetricName: "ProvisionedConcurrencyInvocations",
    Dimensions: [{ Name: "FunctionName", Value: fn }],
  })) {
    for (const m of page.Metrics ?? []) {
      const resource = m.Dimensions?.find((d) => d.Name === "Resource")?.Value;
      if (resource?.endsWith(`:${qualifier}`) && m.Dimensions?.length === 2) dims = m.Dimensions;
    }
  }
  if (!dims) return { invocations: 0, spillover: 0 }; // no data points in the last two weeks
  const end = new Date();
  const start = new Date(end.getTime() - days * 86_400_000);
  const stat = (id: string, metric: string, s: string) => ({
    Id: id,
    MetricStat: { Metric: { Namespace: "AWS/Lambda", MetricName: metric, Dimensions: dims }, Period: 3600, Stat: s },
  });
  const values: Record<string, number[]> = { util: [], inv: [], spill: [] };
  for await (const page of paginateGetMetricData({ client: cw }, {
    StartTime: start,
    EndTime: end,
    MetricDataQueries: [
      stat("util", "ProvisionedConcurrencyUtilization", "Maximum"),
      stat("inv", "ProvisionedConcurrencyInvocations", "Sum"),
      stat("spill", "ProvisionedConcurrencySpilloverInvocations", "Sum"),
    ],
  })) {
    for (const r of page.MetricDataResults ?? []) values[r.Id ?? ""]?.push(...(r.Values ?? []));
  }
  const sum = (xs: number[] | undefined) => (xs ?? []).reduce((a, b) => a + b, 0);
  const util = values.util ?? [];
  return { peak: util.length ? Math.max(...util) : undefined, invocations: sum(values.inv), spillover: sum(values.spill) };
}

async function scalableTargets(aas: ApplicationAutoScalingClient): Promise<Set<string>> {
  const ids = new Set<string>();
  for await (const page of paginateDescribeScalableTargets({ client: aas }, { ServiceNamespace: "lambda" })) {
    for (const t of page.ScalableTargets ?? []) if (t.ResourceId) ids.add(t.ResourceId); // "function:<name>:<qualifier>"
  }
  return ids;
}

async function scanRegion(region: string): Promise<Row[]> {
  const lambda = new LambdaClient({ region });
  const cw = new CloudWatchClient({ region });
  const managed = await scalableTargets(new ApplicationAutoScalingClient({ region }));
  const functions: FunctionConfiguration[] = [];
  for await (const page of paginateListFunctions({ client: lambda }, {})) functions.push(...(page.Functions ?? []));
  const rows: Row[] = [];
  for (const fn of functions) {
    const name = fn.FunctionName ?? "";
    for await (const page of paginateListProvisionedConcurrencyConfigs({ client: lambda }, { FunctionName: name })) {
      for (const pc of page.ProvisionedConcurrencyConfigs ?? []) {
        const qualifier = pc.FunctionArn?.split(":").pop() ?? "";
        const allocated = pc.AllocatedProvisionedConcurrentExecutions ?? 0;
        const memoryMb = fn.MemorySize ?? 128;
        const arch = fn.Architectures?.[0] === "arm64" ? "arm64" : "x86_64";
        const perMonth = allocated * (memoryMb / 1024) * SECONDS_PER_MONTH * PC_GB_SECOND[arch];
        const u = await usage(cw, name, qualifier);
        const aasManaged = managed.has(`function:${name}:${qualifier}`);
        const modifiedDaysAgo = pc.LastModified ? (Date.now() - Date.parse(pc.LastModified)) / 86_400_000 : Infinity;
        let verdict = "in use";
        if (pc.Status !== "READY") verdict = `status ${pc.Status ?? "unknown"}`;
        else if (modifiedDaysAgo < days) verdict = "changed recently: re-check later";
        else if (u.invocations === 0) verdict = "IDLE: no provisioned invocations";
        else if (u.peak !== undefined && u.peak < low) {
          const suggested = Math.max(1, Math.ceil(u.peak * allocated * 1.1)); // peak concurrent use + 10% buffer
          verdict = `LOW: try ${suggested}`;
        }
        let action = verdict.startsWith("IDLE") ? (aasManaged ? "managed by auto scaling" : "would delete (--apply)") : "-";
        if (apply && verdict.startsWith("IDLE") && !aasManaged) {
          try {
            await lambda.send(new DeleteProvisionedConcurrencyConfigCommand({ FunctionName: name, Qualifier: qualifier }));
            action = "deleted";
          } catch (err) {
            action = `failed: ${err instanceof Error ? err.name : String(err)}`;
          }
        }
        rows.push({
          Region: region,
          Function: name,
          Qualifier: qualifier,
          MemoryMB: memoryMb,
          Arch: arch,
          Allocated: allocated,
          Status: pc.Status ?? "",
          PeakUtil: u.peak === undefined ? "-" : `${Math.round(u.peak * 100)}%`,
          PcInvocations: Math.round(u.invocations),
          Spillover: Math.round(u.spillover),
          AutoScaling: aasManaged ? "yes" : "no",
          PerMonth: `$${(Math.round(perMonth * 100) / 100).toFixed(2)}`,
          Verdict: verdict,
          Action: action,
        });
      }
    }
  }
  return rows;
}

function toCsv(rows: Row[]): string {
  const cols = Object.keys(rows[0] ?? {}) as (keyof Row)[];
  const cell = (v: string | number) => `"${String(v).replace(/"/g, '""')}"`;
  return [cols.join(","), ...rows.map((r) => cols.map((c) => cell(r[c])).join(","))].join("\n") + "\n";
}

async function main(): Promise<void> {
  if (!Number.isInteger(days) || days < 1 || days > 14) throw new Error("--days must be 1 to 14: ListMetrics only sees metrics with data in the last two weeks");
  if (!(low > 0 && low <= 1)) throw new Error("--low must be between 0 and 1");
  const rows: Row[] = [];
  for (const region of regions) {
    try {
      rows.push(...(await scanRegion(region)));
    } catch (err) {
      console.error(`${region}: ${err instanceof Error ? `${err.name}: ${err.message}` : String(err)}`);
    }
  }
  if (rows.length === 0) {
    console.log(`No provisioned concurrency configured in ${regions.join(", ")}.`);
    return;
  }
  console.table(rows);
  const idle = rows.filter((r) => r.Verdict.startsWith("IDLE"));
  const monthly = idle.reduce((s, r) => s + Number(r.PerMonth.replace("$", "")), 0);
  console.log(`${idle.length} of ${rows.length} configs had no provisioned invocations in ${days} days: $${monthly.toFixed(2)} a month of idle charge.`);
  if (csvPath) {
    writeFileSync(csvPath, toCsv(rows));
    console.log(`Wrote ${rows.length} rows to ${csvPath}`);
  }
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

npm install @aws-sdk/client-lambda @aws-sdk/client-application-auto-scaling @aws-sdk/client-cloudwatch
npm install --save-dev tsx typescript @types/node

# Report for two Regions, flag anything under 30% peak utilization, write a CSV
AWS_PROFILE=readonly npx tsx find-unused-lambda-provisioned-concurrency.ts --regions us-east-1,eu-west-1 --csv pc.csv

# Delete idle configs that auto scaling doesn't manage
AWS_PROFILE=lambda-admin npx tsx find-unused-lambda-provisioned-concurrency.ts --regions us-east-1 --apply

┌─────────┬─────────────┬──────────────────┬───────────┬──────────┬──────────┬───────────┬─────────┬──────────┬───────────────┬───────────┬─────────────┬───────────┬────────────────────────────────────┬───────────────────────────┐
│ (index) │ Region      │ Function         │ Qualifier │ MemoryMB │ Arch     │ Allocated │ Status  │ PeakUtil │ PcInvocations │ Spillover │ AutoScaling │ PerMonth  │ Verdict                            │ Action                    │
├─────────┼─────────────┼──────────────────┼───────────┼──────────┼──────────┼───────────┼─────────┼──────────┼───────────────┼───────────┼─────────────┼───────────┼────────────────────────────────────┼───────────────────────────┤
│ 0       │ 'us-east-1' │ 'checkout-api'   │ 'live'    │ 1024     │ 'x86_64' │ 20        │ 'READY' │ '85%'    │ 1800000       │ 3100      │ 'no'        │ '$219.00' │ 'in use'                           │ '-'                       │
│ 1       │ 'us-east-1' │ 'search-api'     │ 'prod'    │ 2048     │ 'arm64'  │ 50        │ 'READY' │ '20%'    │ 240000        │ 0         │ 'no'        │ '$876.02' │ 'LOW: try 11'                      │ '-'                       │
│ 2       │ 'us-east-1' │ 'legacy-webhook' │ '7'       │ 512      │ 'x86_64' │ 10        │ 'READY' │ '-'      │ 0             │ 0         │ 'no'        │ '$54.75'  │ 'IDLE: no provisioned invocations' │ 'would delete (--apply)'  │
│ 3       │ 'us-east-1' │ 'report-worker'  │ 'prod'    │ 1024     │ 'x86_64' │ 5         │ 'READY' │ '-'      │ 0             │ 0         │ 'yes'       │ '$54.75'  │ 'IDLE: no provisioned invocations' │ 'managed by auto scaling' │
└─────────┴─────────────┴──────────────────┴───────────┴──────────┴──────────┴───────────┴─────────┴──────────┴───────────────┴───────────┴─────────────┴───────────┴────────────────────────────────────┴───────────────────────────┘
2 of 4 configs had no provisioned invocations in 14 days: $109.50 a month of idle charge.

// schedule-provisioned-concurrency.ts
// Keeps 20 provisioned environments on the "live" alias during business hours and 1 outside them.
// The alias must already have a provisioned concurrency config before Application Auto Scaling manages it.
// Usage: npx tsx schedule-provisioned-concurrency.ts checkout-api live
import {
  ApplicationAutoScalingClient,
  PutScheduledActionCommand,
  RegisterScalableTargetCommand,
} from "@aws-sdk/client-application-auto-scaling";

const [fn = "checkout-api", alias = "live"] = process.argv.slice(2);
const aas = new ApplicationAutoScalingClient({ region: process.env.AWS_REGION ?? "us-east-1" });
const target = {
  ServiceNamespace: "lambda" as const,
  ResourceId: `function:${fn}:${alias}`,
  ScalableDimension: "lambda:function:ProvisionedConcurrency" as const,
};

async function main(): Promise<void> {
  await aas.send(new RegisterScalableTargetCommand({ ...target, MinCapacity: 1, MaxCapacity: 20 }));
  await aas.send(new PutScheduledActionCommand({
    ...target,
    ScheduledActionName: `${fn}-${alias}-business-hours`,
    Schedule: "cron(0 8 ? * MON-FRI *)",
    Timezone: "America/New_York",
    ScalableTargetAction: { MinCapacity: 20, MaxCapacity: 20 },
  }));
  await aas.send(new PutScheduledActionCommand({
    ...target,
    ScheduledActionName: `${fn}-${alias}-after-hours`,
    Schedule: "cron(0 20 ? * MON-FRI *)",
    Timezone: "America/New_York",
    ScalableTargetAction: { MinCapacity: 1, MaxCapacity: 1 },
  }));
  console.log(`Scheduled ${target.ResourceId}: 20 from 08:00 to 20:00 on weekdays, 1 otherwise (America/New_York).`);
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});