How to Reduce Cold Start Time in Firebase Cloud Functions

1import { onRequest } from "firebase-functions/v2/https";
2import { onCall } from "firebase-functions/v2/https";
3
4// Keep 1 warm instance — eliminates cold starts for most traffic
5export const api = onRequest(
6  {
7    minInstances: 1,
8    maxInstances: 100,
9    memory: "512MiB",
10    region: "us-central1",
11  },
12  async (req, res) => {
13    res.json({ status: "ok", cold: false });
14  }
15);
16
17// For callable functions
18export const processData = onCall(
19  {
20    minInstances: 1,
21    memory: "1GiB",
22    concurrency: 10,
23  },
24  async (request) => {
25    return { result: "processed" };
26  }
27);

1import { initializeApp } from "firebase-admin/app";
2import { getFirestore } from "firebase-admin/firestore";
3
4// Initialize with preferRest to avoid gRPC cold start overhead
5const app = initializeApp();
6const db = getFirestore(app);
7db.settings({ preferRest: true });
8
9// This single change can reduce cold starts by 2-5 seconds
10// for functions that use Firestore via the Admin SDK

1import { onRequest } from "firebase-functions/v2/https";
2
3// BAD: Heavy import at top level — loaded on every cold start
4// import sharp from "sharp";
5// import PDFDocument from "pdfkit";
6
7export const generateThumbnail = onRequest(
8  { memory: "1GiB" },
9  async (req, res) => {
10    // GOOD: Lazy-load heavy dependencies only when needed
11    const sharp = await import("sharp");
12    const image = await sharp.default(req.body)
13      .resize(200, 200)
14      .toBuffer();
15    res.setHeader("Content-Type", "image/png");
16    res.send(image);
17  }
18);
19
20export const healthCheck = onRequest(async (req, res) => {
21  // This function does NOT load sharp because it is lazy-loaded
22  // in generateThumbnail, not at the top level
23  res.json({ status: "ok" });
24});

1// functions/src/index.ts — Lightweight entry point
2export { api } from "./api";
3export { processImage } from "./images";
4export { onUserCreated } from "./auth";
5
6// functions/src/api.ts — Only loads API dependencies
7import { onRequest } from "firebase-functions/v2/https";
8import { getFirestore } from "firebase-admin/firestore";
9
10const db = getFirestore();
11db.settings({ preferRest: true });
12
13export const api = onRequest(
14  { minInstances: 1, memory: "512MiB" },
15  async (req, res) => {
16    const data = await db.collection("items").limit(20).get();
17    res.json(data.docs.map((d) => d.data()));
18  }
19);
20
21// functions/src/images.ts — Only loads image dependencies
22import { onRequest } from "firebase-functions/v2/https";
23
24export const processImage = onRequest(
25  { memory: "2GiB" },
26  async (req, res) => {
27    const sharp = await import("sharp");
28    // Image processing...
29    res.json({ status: "done" });
30  }
31);

1import { onRequest } from "firebase-functions/v2/https";
2
3// 256 MiB (default) — cold start ~4s for moderate dependencies
4export const slowStart = onRequest(
5  { memory: "256MiB" },
6  async (req, res) => {
7    res.json({ memory: "256MiB" });
8  }
9);
10
11// 1 GiB — cold start ~2s for the same code
12export const fastStart = onRequest(
13  { memory: "1GiB" },
14  async (req, res) => {
15    res.json({ memory: "1GiB" });
16  }
17);
18
19// 2 GiB — cold start ~1.5s with 2 vCPUs
20export const fastestStart = onRequest(
21  { memory: "2GiB", cpu: 2 },
22  async (req, res) => {
23    res.json({ memory: "2GiB", cpu: 2 });
24  }
25);

1import { onRequest } from "firebase-functions/v2/https";
2import { logger } from "firebase-functions";
3
4// Record module load time (runs once during cold start)
5const moduleLoadTime = Date.now();
6let isFirstInvocation = true;
7
8export const measuredFunction = onRequest(
9  { memory: "512MiB", minInstances: 0 },
10  async (req, res) => {
11    const requestStart = Date.now();
12
13    if (isFirstInvocation) {
14      const coldStartMs = requestStart - moduleLoadTime;
15      logger.info("Cold start detected", {
16        coldStartMs,
17        memory: "512MiB",
18      });
19      isFirstInvocation = false;
20    }
21
22    // Your function logic here
23    const processingTime = Date.now() - requestStart;
24
25    logger.info("Request completed", {
26      processingMs: processingTime,
27      warm: !isFirstInvocation,
28    });
29
30    res.json({
31      processingMs: processingTime,
32    });
33  }
34);