Fluid Compute

Vercel's Fluid Compute reuses function instances across requests, reducing cold starts. Key behaviors:

• Instances process multiple sequential requests before recycling
• Global state persists across requests on the same instance (use for caching, not correctness)
• Concurrent requests may still trigger new instances

Cold start anatomy

Function types on Vercel

Workflow

Step 1 — Create an API route

// app/api/users/route.ts
import { NextRequest, NextResponse } from "next/server";
import { db } from "@/lib/db/client";

export async function GET(request: NextRequest) {
  const searchParams = request.nextUrl.searchParams;
  const page = parseInt(searchParams.get("page") ?? "1", 10);
  const limit = Math.min(parseInt(searchParams.get("limit") ?? "20", 10), 100);
  const offset = (page - 1) * limit;

  const users = await db
    .from("users")
    .select("id, name, email, created_at")
    .range(offset, offset + limit - 1)
    .order("created_at", { ascending: false });

  return NextResponse.json({
    data: users.data,
    page,
    limit,
  });
}

Step 2 — Handle webhooks with verification

// app/api/webhooks/stripe/route.ts
import { NextRequest, NextResponse } from "next/server";
import Stripe from "stripe";

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);

export async function POST(request: NextRequest) {
  const body = await request.text();
  const signature = request.headers.get("stripe-signature")!;

  let event: Stripe.Event;
  try {
    event = stripe.webhooks.constructEvent(
      body,
      signature,
      process.env.STRIPE_WEBHOOK_SECRET!
    );
  } catch {
    return NextResponse.json({ error: "Invalid signature" }, { status: 400 });
  }

  switch (event.type) {
    case "checkout.session.completed":
      await handleCheckoutComplete(event.data.object);
      break;
    case "customer.subscription.deleted":
      await handleSubscriptionCanceled(event.data.object);
      break;
    default:
      break;
  }

  return NextResponse.json({ received: true });
}

Step 3 — Configure cron jobs

// vercel.json
{
  "crons": [
    {
      "path": "/api/cron/daily-digest",
      "schedule": "0 9 * * *"
    },
    {
      "path": "/api/cron/cleanup",
      "schedule": "0 */6 * * *"
    }
  ]
}

// app/api/cron/daily-digest/route.ts
import { NextRequest, NextResponse } from "next/server";

export async function GET(request: NextRequest) {
  // Verify the request is from Vercel Cron
  const authHeader = request.headers.get("Authorization");
  if (authHeader !== \`Bearer ${process.env.CRON_SECRET}\`) {
    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
  }

  const usersToNotify = await getUsersWithDigestEnabled();
  const results = await Promise.allSettled(
    usersToNotify.map((user) => sendDigestEmail(user))
  );

  const succeeded = results.filter((r) => r.status === "fulfilled").length;
  const failed = results.filter((r) => r.status === "rejected").length;

  return NextResponse.json({ succeeded, failed, total: usersToNotify.length });
}

Step 4 — Streaming responses for AI

// app/api/chat/route.ts
import { streamText } from "ai";
import { openai } from "@ai-sdk/openai";

export async function POST(request: Request) {
  const { messages } = await request.json();

  const result = streamText({
    model: openai("gpt-4o"),
    messages,
  });

  return result.toDataStreamResponse();
}

Step 5 — Optimize cold starts

// Lazy-load heavy dependencies to reduce cold start
let _stripe: Stripe | null = null;
function getStripe(): Stripe {
  if (!_stripe) {
    _stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
  }
  return _stripe;
}

// Reuse database connections across warm invocations
let _db: ReturnType<typeof createClient> | null = null;
function getDb() {
  if (!_db) {
    _db = createClient(process.env.DATABASE_URL!);
  }
  return _db;
}

Examples

Idempotent webhook handler

async function handleCheckoutComplete(session: Stripe.Checkout.Session) {
  const idempotencyKey = \`checkout_${session.id}\`;

  // Check if already processed
  const existing = await db
    .from("processed_events")
    .select("id")
    .eq("key", idempotencyKey)
    .maybeSingle();

  if (existing.data) return; // Already processed

  await db.rpc("process_checkout", {
    session_id: session.id,
    customer_email: session.customer_email,
    amount: session.amount_total,
    idempotency_key: idempotencyKey,
  });
}

Fan-out with Promise.allSettled

async function notifyAllChannels(event: AppEvent) {
  const [slack, email, webhook] = await Promise.allSettled([
    sendSlackNotification(event),
    sendEmailNotification(event),
    sendWebhookNotification(event),
  ]);

  return {
    slack: slack.status,
    email: email.status,
    webhook: webhook.status,
  };
}

Decision tree

What kind of compute do you need?
├── Request-response API → Vercel Serverless Function
├── Low-latency, global → Vercel Edge Function
├── Scheduled task → Vercel Cron + Serverless Function
├── Background job > 60s → Vercel Workflow or external queue
├── Real-time bidirectional → WebSocket service (not serverless)
└── Heavy compute (ML, video) → Dedicated instance or GPU

Cold start a problem?
├── P99 latency > 1s → Profile: is it container init or module loading?
│   ├── Module loading → Lazy-load heavy deps, reduce bundle
│   └── Container init → Use Edge runtime or Fluid Compute
├── Webhook must respond < 3s → Acknowledge immediately, process async
└── Cold start acceptable → No action needed

Edge cases and gotchas

• Function timeout is wall-clock, not CPU time: A function waiting 55 s on a database query and 6 s of CPU work will timeout at 60 s total.
• Vercel Cron runs in a single region: Cron-triggered functions execute in the function's configured region, not globally. Time zone matters for schedule expressions.
• Request body size limits: Vercel Serverless Functions accept up to 4.5 MB request bodies by default. For larger payloads, use signed upload URLs to object storage.
• Cold starts compound with dependencies: Each `require` or `import` in the cold path adds latency. A function importing Prisma + Stripe + SendGrid can cold-start at 2–3 s.
• Global variables persist across warm invocations: This is useful for connection pooling but dangerous for per-request state. Never store request-scoped data in module scope.
• Concurrent requests hit different instances: Even with Fluid Compute, two simultaneous requests may land on different instances. Do not depend on shared in-memory state.
• streaming requires `export const dynamic = "force-dynamic"`: Static optimization will buffer the entire response, defeating streaming.
• Webhook retries cause duplicate processing: Always implement idempotency keys for webhook handlers.

Evaluation criteria

Research-backed changes

The biggest delta is Introducing Programmable Flow Protection: custom DDoS mitigation logic for Magic Transit customers. Fold the concrete changes into the operating notes, then discard the fluff.

Fresh signals

• Introducing Programmable Flow Protection: custom DDoS mitigation logic for Magic Transit customers · Cloudflare Blog
• Cloudflare Client-Side Security: smarter detection, now open to everyone · Cloudflare Blog
• How we use Abstract Syntax Trees (ASTs) to turn Workflows code into visual diagrams · Cloudflare Blog
• A one-line Kubernetes fix that saved 600 hours a year · Cloudflare Blog

Next edits

• Add one new tactic based on Introducing Programmable Flow Protection: custom DDoS mitigation logic for Magic Transit customers.
• Rewrite one stale section with today's source language.
• Turn the top signal into a reusable agent prompt.