Serverless Node.js Invocations vs. Static Edge Delivery for Low-Traffic Workloads

Direct Answer

For a page that receives fewer than 30 requests per month, the break‑even between keeping a Lambda‑style function warm and serving a pre‑rendered page from a CDN usually lies at a warm‑up frequency of 15–30 minutes. If you schedule keep‑alives more often than that, the monthly cost of the invocations will exceed the marginal storage and edge‑request fees of a static host.

Cold‑start latency starts to matter only when the first request for a user must wait longer than the user‑experience threshold you have defined (typically 1–2 s for a simple page). For traffic that is truly sporadic, a single slow load is acceptable; if the page is critical or highly interactive, a static edge delivery is the safer choice.

Explanation and Cost Formula

Assume an AWS‑style pricing model (the same logic applies to Azure Functions, Cloudflare Workers, etc.). Let:

• R = monthly request count (≤30)
• C_req = per‑request cost (≈$0.0000002 per request for Lambda)
• T = average function duration in seconds (≈0.3 s for a small Node.js handler)
• M = memory allocated in GB (0.128 GB for the smallest Lambda plan)
• C_gbsec = GB‑second cost (≈$0.00001667 per GB‑sec)
• W = number of scheduled warm‑ups per month (e.g., 8 640 for 5‑min intervals)
• Static_cost = storage + CDN edge request cost (≈$0.02 / GB‑month + $0.08 / 10 k requests)

The monthly cost of a keep‑alive strategy is:

Cost_keep = W * (C_req + M * T * C_gbsec)

The static edge cost is:

Cost_static = Static_cost + R * Edge_request_fee

Setting Cost_keep = Cost_static gives the break‑even W*:

W* = Static_cost / (C_req + M * T * C_gbsec)

Plugging in the numbers above (page size 50 KB, 1 request/day):

• Static_cost ≈ $0.02 / GB‑month + negligible storage ≈ $0.02
• Edge_request_fee ≈ $0.000008 per request (≈$0.08 per 10 k)
• Per‑invocation cost ≈ $0.0000002 + 0.128 GB * 0.3 s * $0.00001667 ≈ $0.000006
• W* ≈ $0.02 / $0.000006 ≈ 3 333 invocations/month

That corresponds to a warm‑up every ≈12 minutes. If you keep the function warm more frequently than that, the static edge model becomes cheaper.

Latency vs. Cost Decision

Cold start latency is a non‑monetary cost. Measure the average first‑request delay after a 1‑hour idle period. If it exceeds the user‑experience threshold you have set (e.g., 1 s for a landing page), consider static delivery or a provisioned‑concurrency plan. For rare visitors where a 2‑second delay is tolerable, the serverless model remains the lower‑cost option.

Uncertainties and What to Verify

• Provider pricing can change; confirm current request, GB‑second, storage, and CDN rates for your region.
• Cold‑start latency depends on Node.js version, bundle size, and memory allocation; run a quick test in your target environment.
• Minimum schedule interval may be 5 minutes on some platforms; if you can’t schedule more often, the break‑even point shifts.

Ask: What is the measured cold‑start latency for your Node.js runtime in the region where your visitors arrive? That figure will refine the cost‑vs‑latency trade‑off.