Ryz Labs/Migrations/Node.js 20 end of life
Migrations

Node.js 20 End of Life: Catching Up Two Majors to Node 24

Node 20 is past its end-of-life date. Here is how to find what still runs on it, what breaks across two majors, and how to land on Node 24 LTS in one controlled move.

Node.js 20 reached end of life on April 30, 2026, per the Node.js Release Working Group schedule. It no longer receives security fixes from the project. If you are still on it, the right target is Node.js 24 LTS, which is supported until April 30, 2028, and the practical approach is a single jump from 20 to 24 that treats the Node 22 changes and the Node 24 changes as one compatibility pass, tested side by side and rolled out service by service.

Key dates

VersionReleasedEnd of lifeStatus on November 21, 2026
20 (Iron), what you run2023-04-182026-04-30Past EOL: unpatched
22 (Jod), intermediate2024-04-242027-04-30Patched, in its final maintenance phase
24 (Krypton), the target2025-05-062028-04-30Patched LTS line

All dates above are from the official Node.js release calendar, checked November 21, 2026. Node 26 (Lithium, end of life April 30, 2029) also exists as a newer LTS line.

Why Node 24 and not Node 22? Node 22 is already in its maintenance phase and ends on April 30, 2027, so stopping there means repeating this whole exercise within months. Node 24 gives you a window to April 2028, and the Node.js project publishes an official 22 to 24 migration guide with codemods for most of the deprecations. Jumping all the way to 26 is possible, yet for a team already behind, the 20 to 24 path is the one with official upgrade notes and tooling today, which is what we cover here.

What end of life means for your systems

The Node.js project is direct about it. Its end-of-life page explains that when newer lines get security patches, EOL lines affected by the same flaw get nothing: "there will not be any new releases for them." Patch a bug in 22 or 24, and a 20 server with the identical code path stays exposed. The last Node 20 release is 20.20.2, a security release dated March 24, 2026, according to the official v20 changelog. Every disclosure after that date is a gap you carry.

Three other effects are named on the same official page, and they compound the longer you wait:

The official releases page adds a simple rule: "Production applications should only use Active LTS or Maintenance LTS releases." Node 20 is neither.

Teams that report under SOC 2 know CC7.1, the criterion that asks companies to detect and manage vulnerabilities. That gets awkward to evidence when the runtime underneath has no upstream fixes coming at all. Our explainer, SOC 2 for AI-assisted codebases, walks through how that criterion reads for current stacks. Buyers raise it too: a security questionnaire from a large customer will ask which runtimes sit in production, and "Node 20, unsupported since spring" invites follow-up.

What end of life does not mean: your services do not stop working on May 1. Nothing switches off. The risk is cumulative and quiet, which is exactly why Node 20 deployments linger long after the date.

Find your exposure

Most teams who are "almost off Node 20" are surprised by what an inventory turns up: a cron job in a forgotten repo, a CI image nobody owns, a serverless function deployed once in 2024. Search every place a Node version can be declared, not only the main app.

Runtime version files and package metadata

Container base images

CI and build tooling

Managed services

Shortcut: drop a package.json, .nvmrc, Dockerfile or workflow file into the free EOL deadline radar and you get back a dated list of runtimes found, with how far past (or before) its deadline each sits. Handy evidence for the remediation ticket.

What changes in the upgrade

Going from 20 to 24 crosses two major releases. Below are the changes most likely to break a real codebase, taken from the official 20 to 22 migration guide, the 22 to 24 guide, and the release notes for 22.0.0 and 24.0.0. Most deprecated APIs have an official codemod you run with npx codemod run followed by the package name.

Import assertions are gone (Node 22)

Node 22 dropped import assertions. Any JSON import written as assert { type: 'json' } fails and must use with { type: 'json' } instead. The official codemod is npx codemod run @nodejs/import-assertions-to-attributes. This one tends to surface in build scripts and config loaders, not just app code.

crypto.createCipher and createDecipher are removed (Node 22)

Node 22.0.0 removed crypto.createCipher() and crypto.createDecipher() (DEP0106). The official guide explains that the old helpers derived keys with MD5 and no salt. The codemod npx codemod run @nodejs/crypto-createcipheriv-migration rewrites calls to createCipheriv with scrypt, random salts and IVs, but the guide warns that new code cannot decrypt data encrypted with createCipher(). If you have stored ciphertext, you need a data migration plan, not only a code change. This is the single change most likely to need a human decision.

Deprecated util helpers start warning (Node 22)

The 22.0.0 changelog moves the util.is family (util.isArray, util.isString, util.isFunction and the rest), util.log and util._extend to runtime deprecation, alongside the Hash, Hmac and fs.Stats constructors. They still work but print warnings, which can flood logs and trip tests that assert on clean stderr. Old dependencies are the usual source.

Bigger stream buffers and a new engine (Node 22)

Node 22 raised the default stream highWaterMark from 16KiB to 64KiB and turned on V8's Maglev compiler by default on supported architectures, per the Node 22 announcement. The announcement tells memory-sensitive users to set setDefaultHighWaterMark explicitly. Services that run many concurrent streams in tight containers should be load tested, not assumed to behave the same.

Native addons must be rebuilt twice over

Node 22 bumped NODE_MODULE_VERSION to 127, so compiled addons built for Node 20 will not load. On top of that, the 22 to 24 guide warns that V8 13.6 can force source changes in addons that touch V8 directly, possibly moving them from C++17 to C++20. Moving addons to Node-API is the official suggestion for avoiding this rebuild treadmill. Audit every dependency with a binding.gyp or a prebuilt binary, such as image processing, database drivers and hashing libraries.

Stricter TLS defaults with OpenSSL 3.5 (Node 24)

Node 24 bundles OpenSSL 3.5 with a stricter default, which the official guide says blocks RC4 suites, sub-2048-bit RSA, DSA and DH keys, and elliptic-curve keys under 224 bits. Connections to old internal services, legacy partner endpoints or devices with weak certificates can fail at the handshake. Test outbound and inbound TLS against every integration before cutover.

Removed and deprecated APIs in Node 24

The Node 24.0.0 release notes list a runtime deprecation of url.parse(), removal of tls.createSecurePair, removal of dirent.path and of calling fs.truncate with a file descriptor, and new deprecations for Zlib classes without new and for passing args to spawn and execFile. Official codemods cover several of these, including @nodejs/dirent-path-to-parent-path, @nodejs/fs-truncate-fd-deprecation, @nodejs/fs-access-mode-constants and @nodejs/tls-create-secure-pair-to-tls-socket. The official deprecation entry for url.parse() goes further: its vulnerabilities do not receive CVE identifiers, so swapping in new URL() beats suppressing the warning.

Platform and tooling shifts (Node 23 and 24)

Official 32-bit Windows downloads stopped at Node 23 and 32-bit armv7 Linux downloads at Node 24; Mac hosts need 13.5 or newer, while glibc 2.28 stays the Linux minimum. Node 24 also ships npm 11, drops the experimental prefix from the permission flag, and has its test runner await subtests on its own. If you pin npm behavior or use the permission model in scripts, update those flags.

The upgrade plan

Because the runtime is already past end of life, the goal is to close the gap quickly without creating an outage. The trick with a two-major jump is to avoid shipping Node 22 to production as an intermediate step. Use 22 only as a diagnostic stop in CI, then deploy 24.

1. Inventory and baseline

Build a list of every service, job and build image on Node 20, with an owner for each. Record current error rates, p95 latency, memory use and the deprecation warnings each service already prints. Without a baseline you cannot tell whether Node 24 made anything worse.

2. Compatibility testing

Add Node 22 and Node 24 to the CI matrix next to 20, so the same test suite runs on all three. Run node with --trace-deprecation to get stack traces for every warning. Apply the official codemods in one branch per codemod so reviews stay small. Rebuild native addons, upgrade dependencies that declare engines below 22, and resolve the createCipher data question before anything else.

3. Staged rollout

Run the Node 24 image side by side with the Node 20 image. Start with low-risk internal services and batch jobs, then a canary slice of traffic on customer-facing services. Compare memory and latency against the baseline, with special attention to stream-heavy and TLS-heavy paths.

4. Cutover and rollback

Move load over gradually. Hold on to a tagged, deployable Node 20 build per service until 24 has carried it through one ordinary release. Reverting is then just redeploying that older image, provided no one-way data change happened, which is exactly why re-encrypting old ciphertext is its own job with its own undo path.

5. Cleanup

Delete Node 20 from CI matrices, base images, .nvmrc files and engines ranges. Set engines to >=24 so nothing regresses. Add a scheduled check, or rerun the radar, so Node 24's April 2028 date is on the calendar now rather than discovered later.

PhaseGoalKey techniqueExit criteria
Inventory and baselineNo surprise Node 20 left anywhereGrep pins, images, pipelines, serverless settingsNamed owner plus recorded metrics per workload
Compatibility testingGreen tests on 24CI matrix on 20, 22 and 24; official codemods; --trace-deprecationSuite passes on 24 with no unexplained warnings
Staged rolloutReal traffic on 24, limited blast radiusParallel 20 and 24 images, small canary sliceErrors, latency, memory equal to the 20 numbers
Cutover and rollbackNode 20 serves nothingGradual shift, old image held for redeployOne ordinary release on 24, nothing reverted
CleanupNo path back to 20Remove 20 from images, CI, engines and version filesZero Node 20 references in the inventory

Risk matrix

RiskLikelihoodImpactMitigationEarly warning
Stored data encrypted with createCipher cannot be read after migrationMediumHighRe-encrypt with createCipheriv in a separate, reversible job before cutoverSearch finds createCipher or createDecipher calls
Native addon fails to loadHighHighRebuild or upgrade every compiled dependency; prefer Node-API packagesModule version mismatch errors in CI on 22 or 24
TLS handshake failures with legacy endpointsMediumHighTest every integration on Node 24; rotate weak keys and certificatesHandshake errors in staging logs
Higher memory under stream loadMediumMediumLoad test; set setDefaultHighWaterMark where neededContainer memory climbing on the canary
Unseen Node 20 jobs stay behindHighMediumInventory across all repos, CI and managed runtimes; radar report per repoRuntime version checks still return v20
Dependency no longer supports old usageMediumMediumUpgrade packages that declare engines below 22; replace abandoned onesnpm engine warnings during install
Deprecation warnings flood logsHighLowFix with codemods; trace with --trace-deprecationSpike in stderr volume after deploy

Typical team shape

Catching up from Node 20 is mostly platform and dependency labor, with small application fixes scattered across many services. Staff it with one lead to run the inventory and sequence services, backend people to apply codemods and chase behavior changes, and a platform or DevOps specialist for images, pipelines and canaries. Old ciphertext from the removed helpers deserves its own owner with security background.

Many teams begin with a pod of 3 to 5 senior engineers (a tech lead plus engineers), and a full pod is about seven. Ryz engineers on your team start from $7,000 per month (our published range is $7,000–$15,000 per engineer per month, mostly mid-level to senior), quoted per team. Ryz engineers work on your team, reporting to your leads. To clear a backlog like this, add Node.js developers or a DevOps engineer; scope your team and we will map people to the inventory.

Not a match for us: a few hours of self-serve freelance work (use a marketplace), or round-the-clock coverage from Europe and Asia (use a global network).

Related

FAQ

Is Node.js 20 still safe to run after end of life?

No. It keeps working, but since April 30, 2026 the Node.js project ships no security fixes for it, and the final 20.x release came out in March 2026. Each disclosure since then is permanently open on Node 20, so exposure grows every month you stay.

Which version should we upgrade to?

Go straight to Node.js 24 LTS, patched through April 30, 2028. Landing on 22 buys only until April 30, 2027 and forces a repeat. The project ships a migration guide and codemods for reaching 24, which keeps a two-major catch-up manageable.

How long does the upgrade take?

Duration comes down to a handful of drivers: count of Node 20 workloads, compiled addons, stored createCipher ciphertext, legacy TLS partners and test coverage. Run the inventory and a 24 CI job first; their results give a real answer for your estate.

Can we pay for extended support?

Yes. Commercial patches for EOL Node lines are available from HeroDevs, NodeSource and TuxCare, which Node.js names as OpenJS Foundation sustainability partners. Node.js itself frames paid support as a stopgap while you upgrade, not a destination.

What does it cost to bring in engineers?

Monthly rates run from $7,000 up to $15,000 for each engineer, with most people mid-level to senior. Multiply headcount by months by rate to size it. Every quote is per team and arrives with a written plan and named engineers.

Questions we didn't answer? Email info@ryzlabs.com.

Thanks — your message has been sent. We’ll get back to you soon.

Something went wrong while sending your message. Please try again or email info@ryzlabs.com.

Explore Ryz Labs

Software development servicesAI development companyIndustriesStaff augmentationAI pod teamsNearshore software developmentHire engineers by roleEngineer ratesGuidesBuyer guidesCase studiesHow we vet engineers

Ryz Labs

Senior engineers on your team. AI pod teams that ship.

Tell us what you're building. You get a scoped plan, a price and the names of the people who would do the work.

  • Only the top 1% of tens of thousands interviewed make it
  • On US business hours, including New York hours
  • Trusted by Fortune 500 engineering teams

Tell us who you need

A Ryz partner replies with a scoped team plan.

Start a conversation →

Prefer to talk? Book a 15-min call →