DEV Community

Cover image for Lambda Is No Longer Just One Function: 10 AWS Changes Before re:Invent 2026
Pawel Zubkiewicz for AWS Heroes

Posted on Edited on Originally published at serverlesspolska.pl

Lambda Is No Longer Just One Function: 10 AWS Changes Before re:Invent 2026

Do you know what your Lambda function is called today?

Just "Lambda function"? Well, not anymore.

Event Function. AWS renamed it on October 12, 2026, and you probably haven't even heard about it. 😉

This rename didn't come out of nowhere. Over the past year AWS shipped plenty of updates for Lambda, API Gateway and EventBridge. We have new kinds of functions, a new event bus, and a few days ago the 15-minute limit many of us lived with for years went away. At least in some cases. The phrase "Lambda function" no longer means one thing.

I've been writing about serverless on Serverless Polska, my Polish-language blog, since 2018. This isn't a tutorial, so you won't find code or configuration steps here. I want to sort out what Lambda functions are today and what to know before re:Invent 2026 brings the next wave of announcements.

Three changes get a deeper look and seven a shorter one, each with a date and a link to the AWS source. Accurate as of November 21, 2026.

1. A Lambda function is now three things

AWS says it plainly in an AWS Compute Blog post from November 19, 2026: Lambda now has three form factors: Event Functions, Web Functions and MicroVMs.

The three AWS Lambda form factors: Event Functions, Web Functions and MicroVMs (AWS diagram)

Source: AWS Compute Blog, "Announcing 30-minute timeout for on-demand AWS Lambda Event Functions", November 19, 2026.

Event Functions are the good old functions we've known for years. They react to events and by default run on demand. According to the AWS announcement from October 12, 2026, only the name has changed. Existing functions don't need rewriting or redeploying.

Web Functions arrived in the same announcement, and this is where it gets interesting. Your code listens on a port itself and handles HTTP requests, e.g. in Express or Hono. One environment handles many requests at once, and AWS describes the billing model as paying for active CPU time and for the environment's memory. So waiting on a database or another service costs no CPU, but memory is still billed. For web apps and APIs that mostly wait for responses from other systems, I'd call this the most important change on the whole list.

MicroVMs were announced by AWS on June 22, 2026 as a new serverless building block with VM-level isolation. Each user or task gets a separate Firecracker-based environment with its own HTTPS address. State can be preserved, and the environment can be paused and resumed, capped at 8 hours of running and paused time combined. You build the image from a Dockerfile. It's meant for running code written by users or generated by AI.

What about Lambda on EC2 servers? Easy to get confused here. Lambda Managed Instances (announced on November 30, 2025) is not another Lambda form factor. It's simply a way to run Event Functions on managed EC2 instances in your account, through a so-called capacity provider. The environment handles many requests in parallel, and billing is based on EC2 pricing, including Savings Plans and Reserved Instances. There's a catch, though, noted in the AWS documentation: a 15% management fee is added to the instance price, and EC2 discounts cover only the instance itself. Since March 27, 2026, functions on Managed Instances can have up to 32 GB of memory and 16 vCPUs (up from 10 GB).

There are also durable functions, which I cover later on.

Here's all of it in one table:

Form factor What it's for How you pay Maximum duration
Event Functions (on demand) Reacting to events Standard Lambda pricing 30 minutes (ESM exceptions: 14 minutes, see below)
Lambda Managed Instances (Event Functions mode) The same functions on EC2 instances in your account EC2 price plus 15% management fee 30 minutes synchronous, 90 minutes asynchronous and with event source mapping (ESM exceptions: 14 minutes, see below)
Web Functions Web apps and APIs over HTTP Active CPU plus environment memory 15 minutes
MicroVMs Isolated user and AI code See AWS pricing (no rates quoted here) 8 hours (running and paused)

If you're planning to migrate to Web Functions or MicroVMs, run the numbers for your traffic on current pricing.

How do I keep it straight in my head?

Roughly like this:

  • Reacting to an event from a queue, a stream or another service? Event Functions.
  • A web app or API that mostly waits on the database? I'd check Web Functions here.
  • Code you don't trust, because a user or an AI model wrote it? MicroVMs.
  • Traffic predictable enough that EC2 instances and their discounts are worth thinking about? Only then would I consider Managed Instances.

Fair warning: this is my heuristic, not an official AWS recommendation.

2. 15 minutes is no longer the limit

Fifteen minutes. For years, that's how long a Lambda function could run.

On November 19, 2026, AWS doubled that limit to 30 minutes for on-demand Event Functions. It covers synchronous, asynchronous and event source mapping (ESM) invocations. Pricing is standard, and the change is live in all commercial regions.

The 15-minute barrier had actually fallen earlier. On September 9, 2026, AWS introduced a 90-minute limit on Lambda Managed Instances, but only for asynchronous and ESM invocations. Synchronous invocations on Managed Instances stayed at 15 minutes back then. After the November change they get up to 30 minutes, while asynchronous and ESM ones keep 90. Both cases come with exceptions: ESM mappings from Amazon MQ and Amazon DocumentDB, as well as Kafka mappings created before November 19, 2026 without provisioned mode, still have a 14-minute limit.

What doesn't this change cover? Web Functions, first of all. According to the table in the AWS Compute post, their limit is still 15 minutes. MicroVMs play in a completely different league: 8 hours of running and pausing. Durable execution is a separate category: up to a year for asynchronous invocations (more below).

So if someone on your team says "Lambda has 30 minutes now", ask which Lambda they mean. The answer depends on the function's form factor, how it's started and the invocation type.

For me, a longer limit means, above all, fewer workarounds. Some tasks we split into chunks just to fit into 15 minutes can now run in a single invocation. Before you crank up the timeout, though, ask yourself whether this work should take that long at all.

3. EventBridge: a new Custom event bus, and the old one is now "classic"

The second rename in this roundup hits EventBridge. On September 24, 2026, AWS announced a new version of the Custom event bus. The existing bus was renamed "Custom event bus - classic", and per the AWS announcement, all existing APIs are unchanged.

What do we get in the new Custom event bus?

  • sharing the bus across accounts via AWS RAM,
  • strict event ordering,
  • the CloudEvents format,
  • event retention for 24 hours, extendable up to a year,
  • a new Subscriber resource,
  • pricing based on data volume instead of event count.

The new bus is available today in 14 AWS regions, including Europe (Ireland) and Europe (Frankfurt).

Let me spend a moment on what you can now send to this bus. An AWS Compute Blog post lists the CloudEvents (JSON), Avro and Protobuf formats. CloudEvents is an open specification for describing events in a common way, developed under the Cloud Native Computing Foundation (CNCF) and adopted by many systems outside AWS, as another AWS Compute post explains. You can send an event in this format to the new bus without reworking it, and its schema stays unchanged.

For me, binary formats are the big change here. EventBridge converts Avro and Protocol Buffers (Google's protobuf) to JSON based on a schema from a registry (AWS Glue Schema Registry or Confluent), so a subscriber can filter and route events on their entire content.

On top of that there's JSONata, which is simply great. In the new bus, a Subscriber can use JSONata expressions to transform an event before it reaches the target: extract fields, rename them or compute new values. It's a separately priced feature, so at high volume, factor it into your math.

You'll probably come across terms like "the new EventBridge" or "the new bus". Officially, it's an enhanced Custom event bus within Amazon EventBridge, not a separate service. I stick to that name because AWS uses it in its announcements.

Your current bus didn't automatically turn into the new one. It keeps working as "Custom event bus - classic", with the same APIs. The capabilities in the list above apply to the new, enhanced Custom event bus.

Before switching, I'd check AWS pricing first. In the us-east-1 region (as of November 21, 2026), the classic bus costs $1 per million events (every started 64 KB chunk of payload counts as a separate event), and the new bus $0.18 per GB of ingested data in the first tier, plus a fee for delivery to subscribers. Paying for data instead of the number of events changes the math one way for lots of small events and another way for a few large ones. So it depends on your event sizes. Run the numbers for your own traffic before migrating.

Seven more changes

Comic: three small robots in an old town market square. One collects envelopes from pigeons at a mailbox, another naps in a hammock next to an hourglass, and the third guards three separate doors with padlocks.

Lambda durable functions

On December 2, 2025, AWS announced durable functions. A function saves checkpoints (steps and waits), so it can pause for up to a year with no compute charges and, after a failure, resume from the last checkpoint. So you can build multi-step processes and AI workflows in Lambda itself, describing the steps in the function's code. Or, as before, in Step Functions. Personally, I still prefer the latter, especially since they got JSONata.

Tenant isolation mode

Since November 19, 2025, you can pass a tenant identifier when invoking a function. Lambda then isolates execution environments per tenant: an environment assigned to one customer won't serve another customer's requests.

Multi-tenant applications, e.g. SaaS platforms, no longer need a separate function per customer to get this kind of isolation. One codebase, and the identifier in the invocation decides how environments are split. With JSON-formatted logging, Lambda adds this identifier to the function logs. I think this could also help with per-tenant cost allocation, although AWS doesn't say so directly.

One caveat: this is about execution environment isolation. Separating customers' data and permissions remains, in my opinion, the job of your application's architecture.

Response streaming in REST APIs

On November 19, 2025, Amazon API Gateway started sending REST API responses progressively, as they become ready. The integration can run for up to 15 minutes, and the response can exceed 10 MB.

So two classic limitations are gone: buffering the entire response and the 10 MB limit. For AI applications that generate a response piece by piece, that makes a big difference.

The announcement covers REST APIs. Note the 15 there: that's how long the integration can run with streaming, and a service that invokes a function synchronously applies its own limit. So my takeaway: the new 30 minutes for Event Functions doesn't mean 30 minutes on the request path.

Native JWT authorizer in REST APIs

Since November 17, 2026, REST APIs in API Gateway have had a new authorizer type. It validates JWT tokens (OIDC, OAuth 2.0) directly in the gateway, without a Lambda authorizer.

Got a function whose only job is validating a token? Now you can remove it from your architecture. Less code to maintain and one less element on the request path. Because, as always: the best code is no code.

The boundary is simple: the authorizer validates tokens. If your authorization contains custom business logic, a Lambda authorizer may still make sense. That's my assessment, so check it against your own use case.

API Gateway execution logs up to 1 MB

On September 9, 2026, the REST API execution log limit went from 1 KB (anything longer got truncated) to 1 MB per event. You can send them to your own CloudWatch Logs, S3 or Firehose, even to several at once.

Troubleshooting will get much simpler. Less guessing about what was in the cut-off part of the log.

And what isn't included? Free logging. These logs are billed as vended logs, and a single event can now be about a thousand times larger. From a FinOps perspective, this is the first line item I'd check on the bill after enabling it.

Webhook Events in EventBridge

On November 20, 2026, the Custom event bus got a managed HTTPS endpoint for receiving webhooks. SaaS applications, AI agents and your own integrations can send events to it, and EventBridge verifies them with HMAC, a token or basic auth.

The popular "API Gateway plus Lambda just to accept a webhook and put it on the bus" pattern is often no longer needed.

Here's the catch: this is about the new Custom event bus. Still on the "classic" version? Then this doesn't apply to you.

EventBridge Scheduler: 589 new API actions

The same day, November 20, 2026, EventBridge Scheduler expanded its integrations with 589 new API actions across 81 AWS services. A schedule can now directly call many more operations, and the new Custom event bus got a templated target that makes scheduled sends to the bus easier.

Fewer Lambda functions that only "wake up at midnight and call one API".

The templated target, however, applies only to the new Custom event bus, not "classic".

Also, API Gateway got Portals, i.e. managed developer portals, and backend mTLS, while Lambda now publishes Event Functions state change events to EventBridge.

Where these changes come from and what's next

As I see it, these changes come partly from the growth of AI and agents, and partly from a long-term, strategic rebuild of the AWS Lambda service itself. We'll see the next chapter at re:Invent 2026, where AWS will surely announce plenty of big changes to Lambda and other serverless services.

I remember the days when a Lambda function was very simple and had just one knob for setting RAM. You couldn't even invoke it automatically from SQS. Of course, it was much less convenient to use back then, but its costs were also much simpler to calculate.

Today, with all these new models, Lambda costs feel incredibly hard to work out, even for me, a self-proclaimed AWS cost expert. Each kind of Lambda has a completely different pricing model: Web Functions charge for active CPU and memory, and Managed Instances for the EC2 price plus 15%.

I hope AWS simplifies this someday.

Which of these changes actually matters for your project? Let me know in the comments.

Top comments (0)