The biggest re:Invent 2025 serverless announcements
Here are the biggest serverless announcements at re:Invent 2025.
Serverless
What you need to know about Lambda Managed Instances
In this post, let’s take a deep dive into Lambda Managed Instances, and understand
* Why you should care
* Important considerations
* When to use it
The biggest pre:invent serverless announcements you may have missed
Here are the best pre:Invent serverless announcements, featuring:
* API Gateway integration with ALB (without NLB)
* API Gateway supports response streaming
* DynamoDB supports multi-attribute composite keys
* ALB adds built-in JWT verification
* Step Functions adds mocking support to its TestState API
* S3 supports Attribute-Based Access Control (ABAC)
* Lambda doesn’t need NAT Gateway anymore!
* Lambda supports native tenant isolation
* Lambda adds provisioned mode for SQS ESM
* Lambda ups max payload size for async invocations to 1MB
* Lambda supports Python 3.14
* Lambda’s Rust support goes GA
* CloudFront introduces flat rate price plan
AppSync: how to implement unauthenticated operations
AppSync doesn’t allow unauthenticated API calls.
To allow users to call your API without first authenticating themselves, you must mimic the behaviour using one of the available authorization methods.
In this post, let’s look at three ways to implement unauthenticated GraphQL operations with AppSync and their pros & cons.
How to version APIs with API Gateway and Lambda
Versioning an API built with API Gateway and Lambda isn’t as straightforward as it sounds.
You need to support multiple live versions without piling up technical debt or duplicating infrastructure.
In this post, we look at practical strategies for managing API versions – from duplicating functions to routing by headers – and weigh the trade-offs so you can choose the right approach for your team.
Understanding push vs poll in event-driven architectures
When we talk about event-driven architectures, we often focus on things like loose coupling, scalability and DDD. But under the hood, the way consumers receive events matters just as much. And it usually comes down to one of two models: push vs poll.
Your choice dictates what service(s) you use and how you handle errors.
So, in this article, let’s compare the two models and understand their pros & cons.
How to use Neon and ephemeral environments to simplify serverless development
Serverful (i.e. paying for uptime) services like RDS makes working with ephemeral environments more difficult and poses a cost concern.
In this artcile, let’s see how Neon’s Serverless Postgres database solves this problem and how we can clone an existing database instantly by branching from it.
We will see how Neon differs from Aurora Serverless v2 and give you a step-by-step guide on how to use Neon with ephemeral environments in both your day-to-day feature development work, as well as in CI/CD pipelines.
Event versioning strategies for event-driven architectures
Event-driven architectures encourage loose coupling.
But we are still bound by lessor forms of coupling such as schema coupling. And here lies a question that many students and clients have asked me:
“How do I version my event schemas?”
In this post, let’s run through some common approaches and why they all suck to some degree and the two most important decisions you need to make.
The pros and cons of Lambdalith
“Lambdalith” refers to deploying monolithic applications using AWS Lambda. This is typically associated with (but not limited to) building serverless APIs.
With a Lambdalith, a single Lambda function handles all the routes in an API. You can use Lambda Function URLs [1] or put the function behind a greedy path in API Gateway.
This contrasts with the “function per endpoint” approach, where a different Lambda function handles each API route.
Lambdaliths has been the source of intense debate in the serverless community. While I generally prefer the “function per endpoint” approach, I have adopted Lambdaliths where it makes sense.
In this post, let’s discuss the pros and cons of Lambdaliths and the nuances that are often overlooked.
How to implement Durable Execution for Lambda (without frameworks)
“Durable Execution” means a system can execute workflows reliably and remember progress even when failures occur. It typically involves persisting progress to avoid repeating side-effects on retries and allowing you to recover gracefully from failures.
It’s commonly associated with workflow orchestrators such as AWS Step Functions and AWS Lambda doesn’t support durability by itself.
But, as you will see in this post, there’s an easy way to add durable execution to Lambda, without needing to adopt a durable execution framework or rewriting your Lambda function as a Step Functions state machine.
And it only takes a few lines of code!