Kill-switch pattern for AI cost control

The pattern

Architecture in one diagram

[Request]
   │
   ▼
[Middleware: cost check]
   ├── Under ceiling: pass through
   └── Over ceiling: disable feature, alert, fallback
   │
   ▼
[AI provider call]
   │
   ▼
[Cost record per feature]
   │
   ▼
[Response]

Code: Node.js

Drop-in middleware (TypeScript)

Wrap every AI call. Ceiling map per feature, atomic check, atomic record, alert at 80%, kill at 100%.

// middleware/aiKillSwitch.ts
import { db } from "@/db";
import { alertSlack } from "@/lib/alerts";

const FEATURE_CEILINGS: Record<string, number> = {
  support_agent: 500,    // $500/month
  doc_search: 300,
  autocomplete: 1000,
};

export async function withKillSwitch<T>(
  featureKey: string,
  fn: () => Promise<{ result: T; costUsd: number }>,
) {
  const monthSpend = await db.aiCost.sum({
    feature: featureKey,
    month: getCurrentMonth(),
  });

  const ceiling = FEATURE_CEILINGS[featureKey] ?? 100;

  if (monthSpend >= ceiling) {
    await alertSlack(`KILL: ${featureKey} hit $${ceiling} ceiling`);
    return { fallback: true, message: "Feature temporarily unavailable" };
  }

  if (monthSpend >= ceiling * 0.8) {
    await alertSlack(`WARN: ${featureKey} at 80% of $${ceiling}`);
  }

  const { result, costUsd } = await fn();

  await db.aiCost.insert({
    feature: featureKey,
    month: getCurrentMonth(),
    cost_usd: costUsd,
    timestamp: new Date(),
  });

  return { result, fallback: false };
}

Multi-tenant

Per-customer ceiling on top of per-feature

Useful for B2B SaaS where a single customer can burn a feature budget. Add the customer check before the feature check.

// Per-customer ceiling on top of per-feature ceiling
const customerSpend = await db.aiCost.sum({
  customer_id: customerId,
  feature: featureKey,
  month: getCurrentMonth(),
});

if (customerSpend >= customerCeiling) {
  return {
    fallback: true,
    message: "Plan limit reached. Upgrade to continue?",
  };
}