AWS Lambda Web Applications: How to Run an HTTP App Without an Adapter

Developers building web applications on AWS Lambda have traditionally needed to adapt their HTTP applications to Lambda's event-driven execution model. Frameworks such as Express.js already know how to handle HTTP requests, but a conventional Lambda function expects an event, processes it, and returns a response.

The AWS Lambda Web Adapter helped bridge this gap by translating Lambda events into HTTP requests. However, developers who want to run a standard web server can now consider another option: AWS Lambda Web Functions.

Introduced in October 2026, Lambda Web Functions allow developers to run supported Node.js web applications directly on Lambda without an additional HTTP adapter. The application listens on a port, handles requests through its existing framework, and receives a managed HTTPS endpoint.

This approach is useful for REST APIs, server-rendered applications, and other HTTP workloads. Let's look at how it works and how to build a simple application.

Understanding AWS Lambda Web Functions

Traditional Lambda functions follow an event-driven programming model. AWS invokes a handler, passes it an event and context, and waits for the handler to return or complete its execution.

A conventional web server works differently. It starts listening on a port and handles incoming HTTP requests through a framework's routing and middleware.

Lambda Web Functions support this HTTP-native model. Instead of converting incoming requests into application-specific Lambda events, the application runs as a standard Node.js HTTP server.

AWS manages the execution environment and HTTPS endpoint, while the application handles requests using its normal web framework. At launch, the managed Web Functions runtime supports Node.js 24.

How the Request Flow Works

The architecture is straightforward:

Browser or API Client
        |
        | HTTPS Request
        v
Lambda Web Function Endpoint
        |
        | HTTP Request
        v
Node.js Web Server
        |
        v
Express Route or Middleware
        |
        v
HTTP Response

The endpoint terminates HTTPS and forwards the request to the application inside the Lambda execution environment.

Your application does not need to manage the endpoint's TLS certificates. Instead, it listens on the host and port provided through the AWS_LAMBDA_HTTP_ENDPOINT environment variable.

Build a Simple Express Application

Let's create a small Express application that returns JSON responses.

Step 1: Create the Project

Create a project directory and initialize npm:

mkdir lambda-web-app
cd lambda-web-app
npm init -y
npm install express

Install Express as a production dependency. The application will use it to define routes and handle HTTP requests.

Update package.json to enable ES modules:

{
  "name": "lambda-web-app",
  "version": "1.0.0",
  "type": "module",
  "scripts": {
    "start": "node index.js"
  },
  "dependencies": {
    "express": "^5.0.0"
  }
}

The dependency version shown is an example. Use a version compatible with your project, and retain the lockfile generated during installation so deployments use a reproducible dependency tree.

Step 2: Write the HTTP Server

Create an index.js file:

import express from "express";

const app = express();

app.use(express.json());

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

app.get("/health", (req, res) => {
  res.status(200).json({
    status: "healthy"
  });
});

app.post("/orders", (req, res) => {
  const { productId, quantity } = req.body ?? {};

  if (
    typeof productId !== "string" ||
    productId.trim() === "" ||
    !Number.isInteger(quantity) ||
    quantity <= 0
  ) {
    return res.status(400).json({
      error: "A valid productId and quantity are required."
    });
  }

  res.status(201).json({
    message: "Order request received",
    productId,
    quantity
  });
});

const endpoint =
  process.env.AWS_LAMBDA_HTTP_ENDPOINT ??
  "127.0.0.1:3000";

const [host, portText] = endpoint.split(":");
const port = Number(portText);

if (!host || !Number.isInteger(port) || port <= 0) {
  throw new Error("Invalid HTTP endpoint configuration.");
}

app.listen(port, host, () => {
  console.log(`HTTP server listening on ${host}:${port}`);
});

The most important part is the server startup configuration.

Lambda provides the address through AWS_LAMBDA_HTTP_ENDPOINT. The application reads that value and starts listening on the assigned host and port.

The local fallback allows developers to run the same application on their computers without requiring Lambda-specific configuration.

The /orders endpoint also performs basic input validation. In a real application, you would add authentication, authorization, business rules, and persistent storage before creating orders.

Step 3: Run the Application Locally

Start the server:

npm start

The application should listen on 127.0.0.1:3000 when the Lambda environment variable is not set.

Test the endpoint:

curl http://127.0.0.1:3000/

Expected response:

{
  "message": "Hello from AWS Lambda Web Functions"
}

You can also test the validation logic:

curl -X POST http://127.0.0.1:3000/orders \
  -H "Content-Type: application/json" \
  -d '{"productId":"P100","quantity":2}'

This local testing step helps verify the HTTP routes before deploying the application.

Deploy the Application to AWS Lambda

Lambda Web Functions use a different deployment model from traditional event-handler functions.

You need an AWS account with the required permissions and an up-to-date AWS CLI that supports the Lambda Web Functions commands.

Step 1: Verify the AWS CLI

Check the installed CLI version:

aws --version

Confirm that your CLI supports the lambda-web command: