AWS Lambda End of Life (EOL) Dates and End of Support (EOS) Dates
AWS Lambda end of life (EOL) and end of support (EOS) dates: 17 AWS Lambda versions have reached EOL, including AWS Lambda .NET 9 (container only) — no longer receiving security updates or patches. AWS Lambda Java 8 (AL2023) is the current supported release, with support through Aug 31, 2029 — 35 versions in active support. Also see Amazon DocumentDB end of support dates for related end-of-life information.
Currently Supported AWS Lambda Releases - Active EOS/EOSL Support (35)
| Release | Released | Deprecated Support | Standard Support |
|---|---|---|---|
| Java 8 (AL2023) | (3 months ago) | (in 2 years and 9 months) | (in 2 years and 7 months) |
| Java 11 (AL2023) | (3 months ago) | (in 2 years and 9 months) | (in 2 years and 7 months) |
| Java 17 (AL2023) | (3 months ago) | (in 2 years and 9 months) | (in 2 years and 7 months) |
| Ruby 4.0 | (6 months ago) | (in 2 years and 6 months) | (in 2 years and 4 months) |
| .NET 10 | (10 months ago) | (in 2 years and 1 month) | (in 1 year and 11 months) |
| Node.js 24 | (11 months ago) | (in 1 year and 7 months) | (in 1 year and 5 months) |
| Python 3.14 | (1 year ago) | (in 2 years and 9 months) | (in 2 years and 7 months) |
| Java 25 | (1 year ago) | (in 2 years and 9 months) | (in 2 years and 7 months) |
| Ruby 3.4 | (1 year and 7 months ago) | (in 1 year and 6 months) | (in 1 year and 4 months) |
| Node.js 22 | (2 years ago) | (in 9 months) | (in 6 months) |
| Python 3.13 | (2 years ago) | (in 2 years and 9 months) | (in 2 years and 7 months) |
| Ruby 3.3 | (2 years and 7 months ago) | (in 9 months) | (in 4 months) |
| .NET 8 | (2 years and 9 months ago) | (in 9 months) | (1 week and 5 days ago) |
| Python 3.12 | (2 years and 11 months ago) | (in 2 years and 1 month) | (in 1 year and 11 months) |
| Java 21 | (3 years ago) | (in 2 years and 9 months) | (in 2 years and 7 months) |
| Node.js 20 | (3 years ago) | (in 9 months) | (6 months ago) |
| Custom Runtime (AL2023) | (3 years ago) | (in 2 years and 9 months) | (in 2 years and 7 months) |
| Python 3.11 | (3 years and 3 months ago) | (in 9 months) | (in 7 months) |
| Ruby 3.2 | (3 years and 5 months ago) | (in 9 months) | (7 months ago) |
| Java 17 | (3 years and 6 months ago) | (in 9 months) | (in 7 months) |
| Python 3.10 | (3 years and 7 months ago) | (in 9 months) | (3 weeks and 1 day ago) |
| Node.js 18 | (4 years ago) | (in 9 months) | (1 year and 2 months ago) |
| Node.js 16 | (4 years and 6 months ago) | (in 9 months) | (2 years and 5 months ago) |
| .NET 6 | (4 years and 8 months ago) | (in 9 months) | (1 year and 11 months ago) |
| Python 3.9 | (5 years and 3 months ago) | (in 9 months) | (11 months ago) |
| Node.js 14 | (5 years and 9 months ago) | (in 9 months) | (2 years and 11 months ago) |
| Custom Runtime (AL2) | (6 years and 3 months ago) | (in 9 months) | (3 months ago) |
| Java 8 (AL2) | (6 years and 3 months ago) | (in 9 months) | (in 7 months) |
| Ruby 2.7 | (6 years and 9 months ago) | (in 9 months) | (2 years and 11 months ago) |
| Java 11 | (7 years ago) | (in 9 months) | (in 7 months) |
| Python 3.8 | (7 years ago) | (in 9 months) | (2 years and 1 month ago) |
| Custom Runtime (AL1) | (7 years and 11 months ago) | (in 9 months) | (2 years and 10 months ago) |
| Python 3.7 | (8 years ago) | (in 9 months) | (2 years and 11 months ago) |
| Go 1.x | (8 years and 10 months ago) | (in 9 months) | (2 years and 10 months ago) |
| Java 8 (AL1) | (11 years and 5 months ago) | (in 9 months) | (2 years and 10 months ago) |
AWS Lambda End of Life (EOL) Releases - No Longer Supported (17)
| Release | Released | Deprecated Support | Standard Support |
|---|---|---|---|
| .NET 9 (container only) | (1 year and 11 months ago) | — | (1 week and 5 days ago) |
| .NET 7 (container-only) | (4 years ago) | — | (2 years and 6 months ago) |
| .NET 5 (container-only) | (5 years and 11 months ago) | — | (4 years and 6 months ago) |
| .NET Core 3.1 | (6 years and 7 months ago) | (3 years and 6 months ago) | (3 years and 7 months ago) |
| Node.js 12 | (7 years ago) | (3 years and 6 months ago) | (3 years and 7 months ago) |
| Node.js 10 | (7 years and 6 months ago) | (4 years and 9 months ago) | (5 years and 3 months ago) |
| Ruby 2.5 | (7 years and 11 months ago) | (4 years and 7 months ago) | (5 years and 3 months ago) |
| .NET Core 2.1 | (8 years and 4 months ago) | (4 years and 7 months ago) | (4 years and 10 months ago) |
| Node.js 8.10 | (8 years and 7 months ago) | (6 years and 8 months ago) | (6 years and 8 months ago) |
| .NET Core 2.0 | (8 years and 10 months ago) | (7 years and 5 months ago) | (7 years and 5 months ago) |
| Node.js 4.3 edge | (9 years and 4 months ago) | (6 years and 6 months ago) | (6 years and 8 months ago) |
| Python 3.6 | (9 years and 7 months ago) | (4 years and 2 months ago) | (4 years and 4 months ago) |
| Node.js 6.10 | (9 years and 8 months ago) | (7 years and 3 months ago) | (7 years and 3 months ago) |
| .NET Core 1.0 | (9 years and 11 months ago) | (7 years and 3 months ago) | (7 years and 4 months ago) |
| Node.js 4.3 | (10 years and 7 months ago) | (6 years and 8 months ago) | (6 years and 8 months ago) |
| Python 2.7 | (11 years and 1 month ago) | (4 years and 5 months ago) | (5 years and 4 months ago) |
| Node.js 0.10 | (12 years ago) | (10 years ago) | (10 years and 2 months ago) |
Your functions keep running after a runtime retires, which is why AWS Lambda end of life catches so many serverless teams off guard. Lambda stops patching a runtime on its deprecation date, then gradually blocks changes to every function still using it. This guide shows the deprecation dates by runtime, how to spot affected functions, and how to upgrade safely.
AWS Lambda End of Life and What Deprecation Means
Each major language release has its own Lambda runtime with a unique identifier such as nodejs24.x or python3.14. Lambda deprecates a runtime when the upstream language maintainers or the underlying Amazon Linux release stop issuing security patches. In nearly every case the end-of-life date is published well in advance, so the Lambda runtime deprecation policy mostly tracks dates you can already look up.
Under the shared responsibility model, Lambda applies patches, bug fixes and security updates to every supported managed runtime through automatic runtime patching. Amazon Web Services treats this maintenance as a cloud-side duty only while a runtime is supported. Once it is deprecated, that duty ends and the work shifts to your developers: your function code and dependencies sit on a platform nobody patches anymore.
What end of support means for your functions
The most reassuring fact is also the most dangerous one: function invocations continue on a deprecated runtime. Nothing stops running on the deprecation date. The risk is quieter. An unsupported runtime collects unpatched security vulnerabilities, and an auditor reviewing compliance will flag it. Teams that need technical support for an incident also lose eligibility on an unsupported runtime, so treat the end-of-life date as a security deadline rather than a cosmetic one.
How Lambda blocks function update and creation
The Lambda deprecation timeline has stages. On the deprecation date, patching stops. Later, Lambda blocks creating new functions on the runtime, and after that it will block function update operations for existing functions, except to move to a supported runtime. Count each stage forward from the end of support date, because every runtime has its own schedule for those three dates and they rarely match.
Supported Runtimes and the Lambda Deprecation Schedule
The table below lists a representative slice of the supported runtimes and their forecast dates from the AWS Lambda documentation. AWS publishes these for planning, and they can change, so confirm against the live runtimes page before committing a migration window. The operating system column matters too: AL2 is Amazon Linux 2 and AL2023 is its successor, and the older base reached its own end-of-life date on June 30, 2026. Trackers such as endoflife.date split the same data into standard support and deprecated support, the second being the window in which Lambda still lets you create and update functions.
| Runtime | Identifier | OS | Deprecation date | Block create | Block update |
|---|---|---|---|---|---|
| Node.js 24 | nodejs24.x | AL2023 | Apr 30, 2028 | Jun 1, 2028 | Jul 1, 2028 |
| Node.js 22 | nodejs22.x | AL2023 | Apr 30, 2027 | Jul 29, 2027 | Aug 31, 2027 |
| Python 3.12 | python3.12 | AL2023 | Oct 31, 2028 | Nov 30, 2028 | Jan 10, 2029 |
| Python 3.11 | python3.11 | AL2 | Jun 30, 2027 | Jul 29, 2027 | Aug 31, 2027 |
| Python 3.10 | python3.10 | AL2 | Oct 31, 2026 | Jul 29, 2027 | Aug 31, 2027 |
| Java 17 (AL2) | java17 | AL2 | Jun 30, 2027 | Jul 29, 2027 | Aug 31, 2027 |
| Java 21 | java21 | AL2023 | Jun 30, 2029 | Jul 31, 2029 | Aug 31, 2029 |
| .NET 8 | dotnet8 | AL2023 | Nov 10, 2026 | Jul 29, 2027 | Aug 31, 2027 |
| Ruby 3.3 | ruby3.3 | AL2023 | Mar 31, 2027 | Jul 29, 2027 | Aug 31, 2027 |
| OS-only | provided.al2023 | AL2023 | Jun 30, 2029 | Jul 31, 2029 | Aug 31, 2029 |
Newer runtime releases sometimes arrive in public preview first, and preview runtimes are not covered by the Lambda SLA. Preview runtimes carry no deprecation commitment, so plan around the dates for generally available runtimes. Lambda also declines to launch a runtime in a new region when it is set for deprecation within six months.
Python, Java, .NET and Ruby runtimes
Python 3.10 is the nearest cliff in this table, with its deprecation date on October 31, 2026. Python 3.8 and Ruby 3.2 have already passed theirs, while .NET 8 follows on November 10, 2026. Java is the easier case: Lambda offers Java 8, 11 and 17 on AL2023, so teams that cannot move to Java 21 still get a longer schedule. Go and Rust have no managed runtime, so they run on an OS-only or custom runtime, which follows the provided.al2023 dates above.
Node.js 22 and Node.js 24 deprecation dates
Node.js 22 reaches its deprecation date on April 30, 2027, and Node.js 24 on April 30, 2028. Node.js releases follow the upstream LTS calendar: even-numbered releases become long-term support (LTS) lines, so pick an LTS runtime over an odd-numbered release that is never promoted. For the same reason Node.js 22 remains a reasonable stop for teams that cannot reach Node.js 24 this quarter.
Node.js 20 EOL on AWS Lambda
Node.js 20 is the runtime many teams are scrambling over right now. Its upstream end-of-life date landed on April 30, 2026, and Lambda followed with the same deprecation date, so the runtime no longer receives security patches. Earlier Node.js lines, including Node.js 18, are further along: Lambda deprecated that one on September 1, 2025. Functions still on either will run, but the clock on blocked updates is running too. The CloudQuery write-up on this runtime reported that creation and update blocks follow in late 2026, so verify the current dates in the deprecated runtimes table instead of trusting a screenshot.
Lambda layers deserve a check at the same time. A layer built for one Node.js version can carry native binaries that break on the next, so rebuild or repoint any layer made for the retired runtime before updates to the functions that use it are blocked.
Node.js 20: what to upgrade to next
For most teams the answer is Node.js 22 now and Node.js 24 as the planned follow-up, because skipping straight to the newest line means taking on two major version jumps of behavior changes in one release. A minor version bump within a line is routine; a major version change is the migration to schedule, test and stage. Lambda never upgrades you across a major version automatically.
Python 3.9 and Python 3.10 Lambda End of Support Cases
Python 3.9 shows how AWS Lambda end of support plays out end to end. Upstream Python ended support for 3.9 in October 2025, Lambda ended support on December 15, 2025, blocked new functions on January 15, 2026 and blocked updates on February 15, 2026. A public GitHub issue for a sample project on this runtime shows the typical response: maintainers bumped the runtime to a newer Python and cut a release, including for generated Amplify stacks whose CloudFormation templates pinned the old identifier. The lesson: runtime identifiers pinned in templates and generated stacks need changing before the block dates. Python 3.10 is next in line, so start its upgrade now rather than after the dates pass.
Finding Functions Affected by Lambda Runtime Deprecation
A single account is easy to audit, but real estates span regions and accounts. Pull the list of every function from the AWS console or API, filter on the runtime field, and sort by how soon each deprecation date arrives. Tools such as AWS Config rules, AWS Trusted Advisor checks, or a CloudQuery sync into Postgres can turn the inventory into one SQL query across multiple accounts. A grouped count of functions per account and runtime tells you which team owns the biggest backlog, and the same query run weekly doubles as a progress tracker for the migration.
Deprecation notifications from the Health Dashboard
Lambda warns you before each deprecation. Each notification arrives by email and in the AWS Health and Personal Health Dashboard views, and Trusted Advisor flags functions that use runtimes near deprecation. Lambda extended the lead time for these deprecation notifications to 180 days, so a notice is a planning signal, not an emergency. Route them to a shared mailbox rather than an individual who may have left.
Listing functions with the AWS CLI
For a quick check in one region, aws lambda list-functions with a query on the runtime field returns the names that still need work. The AWS CLI only looks at one region per call, so loop over regions or use an aggregator when your deployment spans many.
Runtime Upgrade Steps Away from Deprecated Runtimes
Changing a runtime is a configuration change for a zip file package: update the runtime identifier and redeploy the deployment package. For a container image, you rebuild from a newer base image instead. Either way, every Lambda function and the same function code and dependencies must run on the new interpreter, which is why testing matters more than the click itself. Unlike a patch-level runtime update, a runtime upgrade is a small release with its own rollout plan, and remember that Lambda's runtime management controls decide how patch updates reach functions after you move. Scheduled runtime updates inside the same major line are applied automatically, and Lambda rebuilds the execution environment on the new version the next time it cold-starts.
Test, update and verify the runtime version
Work in this order: run your test suite locally on the target runtime version, check the dependencies for native build issues, set any changed environment variables, update the runtime, then watch error rates in production. Infrastructure tools make this repeatable. A SAM template, a CDK stack or a Terraform module can each carry the new identifier, so one pull request moves a whole service. Repeat for the remaining functions once the first one has run clean for a few days.
Function versions, aliases and rollback
Rollback matters here because the old version stays available, still on the retiring runtime, until its update-block date. Publish a new version for the upgraded function and point an alias at it for a small slice of traffic. If errors rise, move the alias back; the old version is still there. Each published function version keeps the runtime it was published with, which makes rollback trivial but also means old versions stay on the deprecated runtime, so delete the ones you no longer need.
Breaking Changes and Migration Risks After EOL
Most moves between adjacent runtimes are quiet, yet a few categories of breaking changes cause nearly all the surprises. Backward compatibility is not guaranteed across major versions, so read the upstream release notes and run your integration tests before touching production. The CloudQuery guide on moving from Node.js 20 to Node.js 22 lists the usual suspects, and the same discipline applies when Python, Java or Ruby functions change versions.
Import assertions and native modules
When you move off a retired Node.js runtime, syntax that older Node.js accepted can fail to parse on the newer line, with import assertions being the classic example. Packages with compiled native modules must be rebuilt, because a binary built against one Node.js ABI will refuse to load on another.
Certificates, streams and buffer changes
Before the update-block date, check what shifts when you leave the retired runtime: certificate loading, default stream buffer sizes and Buffer behavior all shifted between recent Node.js lines. None is dramatic alone, but a function that handles files or calls a service with a private certificate authority can behave differently, so exercise those paths explicitly.
Preventing Future Deprecation Surprises on Lambda
Deprecation recurs every year, so the lasting fix is process, not heroics. Keep an inventory of runtimes, put a policy in your governance rules that no new function may be created on a runtime within twelve months of its deprecation date, and review the schedule each quarter. List which Lambda runtimes each team uses, then define them through infrastructure as code and keep identifiers in one shared variable, so a version bump is a one-line change that CI can verify. You can also limit which runtimes your accounts may use, which stops new work from landing on an expiring line, such as a fresh Lambda function created on Node.js 20 by an old template.