The biggest re:Invent 2025 serverless announcements
Here are the biggest serverless announcements at re:Invent 2025.
Programming
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.
Bye bye schema coupling, hello semantic coupling
What if you don’t have to worry about event versioning or catching breaking changes anymore?
What if event consumers are no longer coupled to the schema of the event and instead, subscribe to their semantics?
I discovered an exciting new way to manage event schemas that will blow your mind!
How to detect and prevent breaking changes in event schemas
How can you prevent accidental breaking changes from creeping into your event schemas?
You can detect and stop breaking changes:
* At runtime, when the events are ingested;
* During development, when schema changes are made;
* Or a combination of both!
In this article, let’s look at three approaches you should consider.
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.