AWS Lambda Web Functions runs your existing HTTP server without an event-handler rewrite

12 October 2026. AWS announces Lambda Web Functions on its blog. Three. That’s now the number of Lambda form factors, all built on Firecracker. 128 concurrent requests. That’s what a single Web Function execution environment absorbs. Why it matters: since Lambda launched in 2014, running Node.js on it meant translating an HTTP server into an event handler that receives an event and returns a response. Lambda Web Functions removes that translation — you deploy the server you already have, and billing follows the CPU your code actually uses instead of the time spent waiting on a database call.

The third Lambda form factor

Lambda now splits into three programming models that share the same Firecracker isolation and the same operational model. Event Functions are the Lambda you already know: a single-concurrent, event-driven handler billed on wall-clock execution time. Web Functions use an HTTP-native model: your code listens on a port and handles standard HTTP requests, with multi-concurrent execution and active CPU billing. MicroVMs provide isolated, stateful sandbox environments with customer-managed lifecycles for running untrusted code.

The three complement each other. A single application might use Event Functions for background async processing, Web Functions for the public API and server-side rendering, and MicroVMs for interactive untrusted code — all in the same AWS account.

The turning point is concurrency. Each Web Function execution environment handles up to 128 concurrent requests, so a burst of traffic shares warm environments instead of mapping every request onto a new one. That’s the inverse of the classic event function model, where one more concurrent request has long meant one more cold start.

What active CPU billing changes

Billing is the other break. A Web Function meters the CPU time your code consumes: time spent waiting on a database query or an API call costs very little CPU. Memory is metered for as long as the execution environment exists. For I/O-heavy workloads — server-side rendering, API backends, and AI inference endpoints streaming tokens — active CPU billing can cut compute cost compared to a handler that pays for every millisecond of waiting.

Concretely, the only difference between your local code and the Web Function is one environment variable. Lambda sets AWS_LAMBDA_HTTP_ENDPOINT to the host and port your server must listen on:

import express from 'express';

const app = express();
const [host, port] = process.env.AWS_LAMBDA_HTTP_ENDPOINT.split(':');

app.get('/', (req, res) => {
  res.json({ message: 'Hello from Lambda Web Functions!' });
});

app.listen(port, host, () => {
  console.log(`Server running on port ${port}`);
});

Locally, you set it yourself: AWS_LAMBDA_HTTP_ENDPOINT=127.0.0.1:3000 node index.js. No adapter, no Lambda-specific wrapper. The announced frameworks cover Express, Hono, Fastify and Next.js — in practice, any Node.js server that listens on a port.

One-command deploys, immutable revisions

Deployment is a single line, with no prior resource provisioning:

aws lambda-web deploy --name my-web-app --code ./my-app

The CLI bundles the source, creates the Web Function, publishes its first revision, attaches an endpoint, and returns a live HTTPS URL in under a minute. A revision is an immutable snapshot of the code; an endpoint is the URL that routes traffic to a revision, or splits it across several. Updating code means re-running the same command: the CLI detects the existing function, uploads a new revision, and points the endpoint at it.

For a gradual rollout, traffic shifts between revisions with one call:

aws lambda-web update-web-function-endpoint \
  --function-name my-web-app \
  --endpoint-name dev \
  --auto-deployment-mode Disabled \
  --revision-weights '[{"revisionId": "<current>", "weight": 90}, {"revisionId": "<new>", "weight": 10}]'

This canary sends 90% of traffic to the current revision and 10% to the new one — the equivalent, in one command, of the blue/green or canary release teams usually assemble out of CodeDeploy or weighted routing.

Multi-region distribution becomes a flag

The most striking part for an SRE is global distribution. Deploying across three regions fits in one argument:

aws lambda-web deploy --name my-web-app --code ./my-app \
  --regions us-east-1,eu-west-1,ap-northeast-1

Lambda replicates the code across all three regions and configures latency-based routing automatically, through a single global URL (<domain>.lambda-web.global.on.aws). Each request is routed, on a best-effort basis, to the region with the lowest latency for the caller. What yesterday took CloudFront, regional deployments and Route 53 latency-based routing now collapses into a list of regions on the deploy command.

A different concurrency and billing model

Behind the simplified deployment, the real novelty is the execution model. A classic Event Function handles one invocation at a time and bills on wall-clock execution time; a Web Function accepts up to 128 concurrent requests in the same warm environment and bills on active CPU. Two practical consequences follow.

The first is cold starts. A burst of traffic shares already-running environments instead of provisioning one per request, so cold-start latency stops being paid on every additional concurrent request. The second is billing: I/O wait costs almost nothing. An application that spends most of its time querying a database or streaming tokens sees its cost track the CPU it burns rather than the time it waits — the exact inverse of the wall-clock model, where a sleeping request is billed the same as a computing one.

That shift has a design corollary. On the event-driven model, you optimized to never leave a handler idle; on the HTTP-native model, you optimize for the server to answer quickly and yield, since it’s the CPU consumed — not the request duration — that sets the cost. Teams that migrate therefore gain more by reducing cycles burned than by shaving milliseconds of latency.

Verdict

Lambda Web Functions targets a specific niche: the interactive HTTP application, rich in I/O wait, that teams currently deform to fit the event-driven mould. If you run a Node.js API, server-side rendering, or an endpoint that streams tokens, try it — you keep the server you have, you gain concurrency, and you stop paying for waiting. If your workload is pure event processing — queues, SQS consumers, S3 triggers — stay on Event Functions: the event model remains the right tool there, and migrating buys you nothing. If you orchestrate untrusted or stateful code, that’s the job of MicroVMs, not Web Functions. The bigger signal is elsewhere: AWS is converging on the same conclusion as Cloudflare Workers, Deno Deploy and Vercel — the standard HTTP server is once again the unit of compute that matters, and the infrastructure now adapts to the code rather than the reverse.

References

• AWS — Announcing AWS Lambda Web Functions (12 October 2026)