AWS Lambda

AWS’s functions service: upload a handler, connect a trigger, and pay per request and per millisecond.

What it is: Serverless functions (FaaS)
Type: Managed service on AWS
Made by: Amazon Web Services
License: Proprietary
Facts checked: 5 October 2026

What it is

A Lambda function is a handler plus settings: a runtime (or a container image), a memory size from 128 MB to 10,240 MB, and a timeout of up to 15 minutes. CPU scales with memory; at 1,769 MB a function gets the equivalent of one vCPU. Each request runs in an execution environment, a Firecracker microVM that handles one request at a time. The first request to a new environment pays a cold start (downloading code, starting the runtime and running your initialisation code); later requests reuse the warm environment, so connections and clients created outside the handler carry over.

Lambda’s strength is how it plugs into the rest of AWS. Some services push events to it (API Gateway, S3 notifications, SNS, EventBridge). For queues and streams such as SQS, Kinesis and DynamoDB Streams, Lambda runs an event source mapping that polls for you, hands your function batches of records and scales the number of pollers with the backlog. Billing is per request plus GB-seconds, metered to the millisecond, with a monthly free tier of one million requests and 400,000 GB-seconds.

Why teams pick it

No servers or idle cost: quiet functions cost nothing, and scaling to thousands of parallel copies is automatic
Built-in triggers from most AWS services, including managed polling of SQS and Kinesis
Fine-grained IAM: each function gets its own execution role
Provisioned concurrency and SnapStart cut cold starts when latency matters

Watch out for

15-minute maximum per invocation (90 minutes only for async and queue-driven calls on Lambda Managed Instances); longer jobs need durable functions, Step Functions or ECS
Payloads are capped at 6 MB for synchronous calls (200 MB when streaming the response) and 1 MB for asynchronous ones
Default account limit of 1,000 concurrent executions per Region, shared by all functions; a spike in one can throttle the others
Cold starts range from under 100 ms to over a second, and one request per environment means many connections to your database

Alternatives

What all serverless functions (faas) have in common →

Beta9Open sourceThe open-source engine behind Beam’s cloud: decorate a Python function and it runs as an autoscaling GPU endpoint, task queue or sandbox, on Beam or on your own Kubernetes cluster.

Cloudflare Browser RunRenamedCommercialHeadless Chrome on demand in Cloudflare’s network, called Browser Rendering until April 2026: one HTTP call for a screenshot, PDF, Markdown or crawl, or a full browser session driven by Puppeteer, Playwright, CDP or an AI agent.

Cloudflare WorkersCommercialFunctions that run in V8 isolates on Cloudflare’s network, close to the user, with almost no cold start.+1 Wrangler FissionOpen sourceOpen-source functions on Kubernetes: a pool of warm, generic pods takes your code on the first call, so cold starts stay around 100 ms.

workerdOpen sourceThe open-source JavaScript and WebAssembly server runtime behind Cloudflare Workers, which you can run yourself as an application server, a local dev server or a programmable HTTP proxy.

Workers AICommercialServerless inference on GPUs in Cloudflare’s network: call one of 50+ open models by name from a Worker binding or a REST API, and pay per unit of GPU work instead of renting GPUs.

How it fits with other technologies

What AWS Lambda uses

What uses AWS Lambda

A handler that writes SQS messages to DynamoDB · python

import json
import boto3

# created once per execution environment and reused on warm invocations
table = boto3.resource("dynamodb").Table("orders")

def handler(event, context):
    for record in event["Records"]:  # a batch of up to 10 SQS messages by default
        order = json.loads(record["body"])
        table.put_item(Item=order)
    return {"processed": len(event["Records"])}

See it in a real stack

Serverless web app on AWS →

Live modeldata or requestresponsebusy / idle instance

Open in playground

What you’re watchingPage loads go to CloudFront and are mostly cache hits; misses fetch from S3. API calls go to API Gateway, pass its throttle and run on Lambda, which reads and writes DynamoDB. Watch Lambda add instances, with cold starts in amber, when calls bunch up.

Event-driven order processingCheckout publishes one event to Kafka; payments, inventory and email each consume it at their own pace.Apache KafkaPostgreSQLAWS Lambda CQRS with a static read sideCommands update PostgreSQL; a Lambda projector rewrites the affected JSON views in S3, and CloudFront serves every read without touching a database.Amazon API GatewayAWS LambdaPostgreSQLAmazon SQSAmazon S3Amazon CloudFront Background jobs with a queueThe API drops slow work onto SQS and returns at once; a pool of Fargate workers drains the queue at a steady pace.AWS LambdaAmazon SQSAWS FargateAmazon S3 IoT telemetry pipelineDevices stream readings into Kinesis; Lambda writes them to TimescaleDB for Grafana, and raw data is archived to S3.Amazon Kinesis Data StreamsAWS LambdaTimescaleDBAmazon S3Grafana

Worth exploring

Article· August 2025lambda to eks pod migrationAWS re:Post community questionA short Q&A on what replaces Lambda’s built-in triggers, SQS polling and scaling when functions move to EKS pods. The useful answer points to KEDA (with Karpenter) for scaling pods on queue depth; the longer answer is an unreviewed AI-generated checklist from AWS’s own assistant, so treat it as a starting list, not guidance.

Article· January 2025How to create Kubernetes Jobs from AWS LambdaCloudfleetA tutorial for a Lambda function (a Bash custom runtime that downloads kubectl on start) that runs kubectl commands against a cluster, used here to launch a Kubernetes Job in response to an event. It is written for Cloudfleet’s own managed Kubernetes and its CLI, so the authentication steps need changing for other clusters, and passing raw kubectl arguments in an event is fine for a demo but too permissive for production.

Article· August 2023Using Kubernetes with AWS Lambda: Scaling Up Your Serverless ApplicationsRohit Ghumare, LumigoA vendor blog post whose concrete part is a walkthrough of creating a Lambda function from an EKS cluster with the AWS Controllers for Kubernetes (ACK) Lambda controller, closely following AWS’s own 2022 tutorial. The benefits section is vague and blurs what Kubernetes and Lambda each do, and the post ends with a pitch for Lumigo’s observability product.

Article· March 2023The Great Lambda Migration to Kubernetes Jobs: a Journey in Three PartsLiav Yona, InfoQA first-person account of how Firefly moved event-driven work off Lambda (after hitting the 15-minute timeout), briefly onto ECS, and finally onto Kubernetes Jobs on EKS, with practical notes on reusing container images, swapping an IAM trust policy for EKS OIDC, moving environment variables into ConfigMaps and a blue/green cutover. It is one company’s story with few numbers, and the author’s employer sells infrastructure-as-code tooling, which colours the emphasis on IaC.

Article· August 2022Deploying AWS Lambda functions using AWS Controllers for Kubernetes (ACK)Rajdeep Saha, AWS Compute BlogAWS’s step-by-step tutorial for managing Lambda functions as Kubernetes custom resources: install the ACK Lambda controller in EKS, give it IAM permissions through IRSA, then kubectl apply a Function manifest that points at code in S3. It explains why you might (one GitOps and RBAC model for pods and functions) but, being AWS’s own post, not the drawbacks.

Article· May 2021Spice up Your Kubernetes Environment with AWS LambdaLiav Yona, MediumShows how a Lambda function triggered by SQS or SNS can forward events to an internal (ClusterIP) service in EKS through the Kubernetes API server’s service proxy, using IAM-to-RBAC mapping instead of exposing an endpoint, with code on GitHub. A clever pattern, but written for 2021-era EKS: it maps the IAM role through the aws-auth ConfigMap, and it routes application traffic through the cluster’s control plane.

Article· February 2021Alternative to AWS lambda serverless concept in Kubernetes?Stack Overflow question by ajsgA team running everything on Kubernetes asks how to get Lambda-style, per-request scaling for loading AI models from S3. The 2021 answers name Knative, KFServing (now KServe) and Kubeless (since archived), which makes it a quick snapshot of the options rather than an up-to-date guide.

Article· October 2020Is there a way to containerized a normal AWS Lambda function?Stack Overflow question by Sivvie LimA newcomer asks how to move an SNS-triggered Lambda function into a container on EKS. The answers, from October 2020, point to the lambci/docker-lambda images (since deprecated in favour of AWS’s official Lambda base images) and to Knative; read it mainly for the question, which is a common one, rather than for current tooling.

ArticleUsing Lambda with KubernetesAWS Lambda Developer GuideAWS’s short docs page on managing Lambda functions through the Kubernetes API, with either AWS Controllers for Kubernetes (ACK) or Crossplane, and the use cases for each (reusing RBAC and IAM roles for service accounts, GitOps, tag policies). It covers provisioning only: the functions still run on Lambda, not in your cluster.

All resources →

Where it came from2013–2025

Even on EC2, reacting to something small, like a file landing in S3 or a row changing in DynamoDB, meant running a server that sat waiting for it, sized, patched and paid for around the clock. In 2013 AWS’s Tim Wagner and Jeff Barr talked about a service where developers could hand over just their code and let the cloud store and run it. Wagner wrote the PRFAQ (Amazon’s mock press release and FAQ) that proposed it.

AWS announced Lambda at re:Invent on November 13, 2014, as a preview. It ran only Node.js, could be triggered by S3, DynamoDB and Kinesis, let a function use 128 MB to 1 GB of memory for up to 60 seconds, and charged per request plus compute time in units of 100 milliseconds. It was declared ready for production on April 9, 2015, adding synchronous request/response calls and SNS as a trigger. To keep customers apart, AWS first ran functions on traditional VMs, then built Firecracker so it could scale faster without giving up that isolation.

Lambda became the reference point for what people now call “serverless”. Its limits have grown steadily (15-minute timeouts, 10 GB of memory, container images, 1 ms billing), and in 2025 durable functions let one function pause and resume across steps for up to a year.

Why it’s built this way

Triggered by events from other AWS services: Lambda launched as the code that runs when something changes in S3, DynamoDB or Kinesis, so nobody had to keep a server polling for it. Those integrations are still its main reason to exist.
Billing per request and per slice of runtime: Charging in 100 ms units (1 ms since 2020) instead of per hour means idle code costs nothing, which is what makes small, spiky workloads cheap.
Virtual machines rather than shared containers: Containers were faster and denser, but AWS chose VM-level isolation between customers from the start. When plain VMs proved too slow to scale, it built Firecracker microVMs instead of relaxing the boundary.

Timeline

2013
Tim Wagner writes the PRFAQ proposing Lambda
2014
Preview announced at re:Invent on November 13, Node.js only
2015
Ready for production on April 9, with synchronous calls
2018
AWS open-sources Firecracker, the microVM monitor under Lambda
2020
1 ms billing, 10 GB memory and container image support
2022
SnapStart restores functions from snapshots to cut cold starts
2025
Durable functions add checkpointed, multi-step workflows in December

Sources10 · facts checked 5 October 2026

Improve this page on GitHub