AWS Lambda End of Life (EOL) Dates and End of Support (EOS) Dates

Latest Release: Java 8 (AL2023)

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.

AWS Lambda end of life dates timeline — release schedule chart of the 8 most recent AWS Lambda versions, mapping active support and security support windows against their EOL dates
AWS Lambda end of life dates and end of support (EOS) dates shown as a release schedule — support windows for the 8 most recent AWS Lambda releases of 52 total. Each bar runs from the release date to the end of security support, with the dashed line marking today. Exact AWS Lambda EOL, EOS and EOSL dates for every version are listed in the tables below.

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.

RuntimeIdentifierOSDeprecation dateBlock createBlock update
Node.js 24nodejs24.xAL2023Apr 30, 2028Jun 1, 2028Jul 1, 2028
Node.js 22nodejs22.xAL2023Apr 30, 2027Jul 29, 2027Aug 31, 2027
Python 3.12python3.12AL2023Oct 31, 2028Nov 30, 2028Jan 10, 2029
Python 3.11python3.11AL2Jun 30, 2027Jul 29, 2027Aug 31, 2027
Python 3.10python3.10AL2Oct 31, 2026Jul 29, 2027Aug 31, 2027
Java 17 (AL2)java17AL2Jun 30, 2027Jul 29, 2027Aug 31, 2027
Java 21java21AL2023Jun 30, 2029Jul 31, 2029Aug 31, 2029
.NET 8dotnet8AL2023Nov 10, 2026Jul 29, 2027Aug 31, 2027
Ruby 3.3ruby3.3AL2023Mar 31, 2027Jul 29, 2027Aug 31, 2027
OS-onlyprovided.al2023AL2023Jun 30, 2029Jul 31, 2029Aug 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.

EOL dates of related software products