php2shell patches (CVE-2026-109618 and CVE-2026-109619) for EOL PHP are out now. With sales replies slower than usual due to high demand, the fastest route to patched packages is to buy ELS for Runtimes online (opens in new tab). Read the patch FAQ

Go straight to an AI summary of this blog post instead

  • Summarize this post with Perplexity
  • Summarize this post with Gemini

Key Takeaways

  • Node.js follows a predictable LTS lifecycle of about 30 months.
  • End-of-life Node.js versions expose systems to unpatched CVEs, compliance failures, and dependency breakage.
  • The safest path is to upgrade to a supported LTS version when possible.
  • If an immediate upgrade isn’t feasible, TuxCare helps keep your applications patched and compliant beyond end of life.

When a Node.js version reaches end of life, the support lifecycle has completed – and the maintainers stop issuing security patches. Any vulnerability disclosed after that date won’t be fixed by the community or through official channels. If your systems are still running that version, the exposure is all yours to manage.

This is already the reality for teams running Node.js versions 12, 14, 16, or 18, all of which have passed their EOL dates. The Node.js 20 end-of-life date follows on April 30, 2026. If you haven’t planned for this yet, the time is running out.

This article covers what Node EOL means, the exact dates you need to know, the risks of running an unsupported version, and the options available to your team – including how to stay secure if an upgrade is not on the table right now.

What Does Node EOL Mean?

Node EOL – or Node.js end of life – is the date when the team behind the Node.js project stops maintaining a version. No security fixes are issued for newly discovered CVEs. Bug fixes and product updates stop. The version is marked as unsupported and risky for production environments.

This doesn’t mean your application stops running. Your code will still execute. The issue is whether your applications stay secure and compliant. If a security vulnerability – even a critical severity one – is found in any version after its EOL date, it won’t be fixed. Your system stays exposed until you upgrade or opt for extended support.

Node.js Lifecycle Explained

Node.js follows a fixed release schedule. Each major version moves through clear support phases before it reaches its EOL point.

Here is how the lifecycle works:

nodejs lts lifecycle phases

1. Current Release

A new major version becomes “Current” after its release. It receives active development and new features. This phase lasts about six months and is not recommended for production use.

2. Active LTS (Long-Term Support)

After six months, even-numbered versions (12, 14, 16, 18, 20, 22) move to the Active LTS phase. Odd-numbered versions (13, 15, 17, 19) do not receive LTS status. They are dropped after six months. For production systems, only LTS versions are relevant.

LTS versions continue to receive security patches, bug fixes, and stability improvements for about 12 months.

3. Maintenance LTS

After Active LTS ends, the Node.js version enters the Maintenance LTS. In this phase:

  • Security patches continue.
  • Only critical bug fixes are released.
  • No new features are added.

This phase lasts about 18 months.

4. End of Life (EOL)

When Maintenance LTS ends, the version reaches its end of life. At this point:

  • No more security patches are issued.
  • No bug fixes are provided.
  • The version is officially unsupported.

Note: For Node.js versions, from the start of Active LTS to the EOL date, users typically receive about 30 months of support for them. After that, organizations must upgrade or find another way to maintain security.

Node EOL Dates and Support Timeline

The table below covers all Node.js LTS releases and their official EOL dates.

nodejs lts releases end of life dates

You can use the EOL dates above to confirm where each version stands and whether your current deployment falls within or outside official support policies. To check the current release status of the Node.js version running on your system, run:

node -v

Node 20 EOL: What You Should Know

Node.js 20 reaches end of life on April 30, 2026. For a version that entered Active LTS in October 2023, it has seen broad adoption in production environments. However, from May 1, 2026, any vulnerability discovered in Node.js 20 won’t receive an official patch. Given how widely it’s deployed, it is likely to remain an active target for researchers and threat actors when new CVEs surface affecting this version.

For teams currently running Node 20, the question isn’t whether to act – it’s which action makes sense given your timeline, codebase, and operational constraints. Upgrading to Node.js 22 is the straightforward path if your dependencies support it.

If they don’t, or if your migration timeline extends beyond the EOL date, TuxCare’s Endless Lifecycle Support for Node.js provides ongoing security patches while you plan and execute your upgrade. ELS covers Node.js 12, 14, 16, 18, and 20.

Risks of Running an EOL Node.js Version

Running an EOL Node.js version doesn’t trigger an immediate failure. When the support policies dictate that patches stop flowing, the risk accumulates over time – across several dimensions that matter to security, compliance, and operational stability.

Unpatched Security Vulnerabilities

When a CVE is disclosed that affects an end-of-life version, no official patch will be issued for it. If the same vulnerability affects a supported release line, that line gets patched and the fix is also made public – which effectively hands anyone a detailed map of an unaddressed exposure in the EOL version. The longer you stay on an unsupported version, the more of these disclosures accumulate.

To learn more about how unpatched vulnerabilities impact legacy runtimes, check out our resource on Node.js 18 EOL.

Compliance Failures

Most security frameworks and regulatory standards, including PCI DSS, HIPAA, and ISO 27001 requires that software dependencies are supported and receiving security updates. Running an EOL runtime is a straightforward finding in any audit. For teams in regulated industries, this isn’t a theoretical concern. It’s a real barrier to certification and a liability in vendor security assessments.

According to the 2025 State of Open Source Report, enterprises running EOL software such as CentOS are nearly three times more likely to fail compliance audits – a risk pattern that also applies to unsupported runtimes like Node.js.

Dependency and Toolchain Breakage

The Node.js runtime doesn’t exist in isolation. As the ecosystem moves forward, npm packages drop support for older release numbers, CI/CD tooling updates its own requirements, and shared system libraries evolve. What works today on an EOL version may not work six months from now – not because you changed anything, but because everything around it did.

Ecosystem Drift

Over time, staying on an EOL version means falling further behind on performance improvements, language features, and security primitives that newer versions take for granted. The codebase becomes harder to maintain, harder to hire for, and harder to migrate away from the longer it stays in place. The cost of upgrading doesn’t decrease with time – it increases.

Options After Node End of Life

Reaching an EOL date doesn’t leave your team without options. Here are the realistic options, without ranking them by preference – context determines which one fits.

Upgrade to a Supported LTS Version

The standard upgrade path is moving to Node.js 22, which is currently in Maintenance LTS, or Node.js 24, which is in Active LTS. For greenfield applications or codebases with well-maintained dependencies, this is often straightforward. For larger or older codebases, the friction comes from dependencies that haven’t kept pace, packages that don’t support newer Node versions, or internal modules that rely on APIs that have changed. A security audit before committing to an upgrade timeline will tell you quickly how much work is involved. In some cases, it may need months of validation, increasing upgrade effort and timeline.

TuxCare’s Endless Lifecycle Support

For teams that need more time to execute their upgrade strategy to a supported LTS release, TuxCare’s Endless Lifecycle Support (ELS) provides continued security patches for version numbers beyond their official end-of-life date. TuxCare currently supports Node.js versions 12, 14, 16, 18, and 20, delivering security patches for as long as your team needs them. This keeps your systems and applications protected and compliant while you execute a migration on a timeline that makes sense for your organization.

Extended support is a bridge, not a destination. The goal is to reach a supported LTS version when it is feasible. But for teams managing complex dependency chains, regulated environments, or constrained engineering capacity, it’s a practical way to avoid trading one risk (EOL exposure) for another (a rushed, under-tested upgrade). For some organizations, a rushed migration is riskier than staying on an old version.

With ELS for Node.js, you can effectively:

  • Reduce exposure to new CVEs
  • Maintain compliance posture
  • Buy time for structured upgrades
  • Avoid rushed migrations

Visit the CVE tracker to see vulnerabilities affecting Node.js and available fixes from TuxCare’s ELS across different versions.

tuxcare cve tracker nodejs els

Re-platform

Some teams use an EOL event as a trigger to evaluate whether Node.js is still the right runtime for their workload. Switching to a different runtime or language is rarely the fastest option, but sometimes it’s worth considering if the application is already due for a modern re-architecture. This is a longer-term play focused on future-proofing and not a response to an imminent EOL date.

Isolate the EOL Environment

In a few cases, network isolation can help reduce the attack surface of a system running an EOL version. This means limiting inbound and outbound access, tightening firewall rules, and ensuring the EOL environment has no unnecessary exposure to public networks or sensitive internal systems. Isolation doesn’t eliminate the risk – it contains it. It’s a mitigation effort, not a solution, and it also doesn’t address compliance requirements.

Accept the Risk

This is also a choice, and it’s worth including it. Some teams make a deliberate decision to run EOL software and accept the risk. The problem is that this decision is often made implicitly – by not acting – rather than through a formal risk assessment. If your organization is running an EOL Node version without a documented risk acceptance, an active mitigation strategy, or a migration plan, you’re not managing the risk. You’re ignoring it. That distinction matters when things go wrong.

Manage Node EOL Safely with TuxCare

Running an EOL Node.js version is a manageable problem – but only if you’re actively managing it. Ignoring the EOL date, or treating it as low risk, is how many organizations end up with unpatched CVEs in production, leading to security risks and audit findings they can’t easily explain.

The right approach depends on where your team is. If you have the capacity and dependency support to upgrade now, Node.js 22 or 24 is where you should be heading. If you’re not there yet – because of codebase complexity, resource constraints, or a migration timeline that extends beyond EOL – you need security coverage for the gap.

TuxCare’s Endless Lifecycle Support for Node.js provides that coverage. It delivers security patches for Node.js 12, 14, 16, 18, and 20 for as long as your team needs them, giving you a defensible security posture while you migrate on a timeline that works for your organization.

Summary
Node.js End-of-Life: Dates, Risks & What to Do Next
Article Name
Node.js End-of-Life: Dates, Risks & What to Do Next
Description
Worried about Node EOL? Learn when different versions reach EOL, what risks it brings, and how to plan your upgrade or extended support strategy.
Author
Publisher Name
TuxCare
Publisher Logo

Join 4,500+ Linux & Open Source Professionals!

2x a month. No spam.

Table of Contents
Get the open-source security answers you need

Join 4,500+ Linux & Open Source Professionals!

2x a month. No spam.