Node.js 22 LTS in Production: 2026 Guide, End-of-Life and Upgrade Path

Node.js 22 was released on 24 April 2024 and became Active LTS on 29 October 2024. It moved into Maintenance LTS on 21 October 2025 and reaches end-of-life on 30 April 2027, so in late 2026 the key question for most teams is no longer whether to adopt Node.js 22, but how long to stay on it and when to move to Node.js 24 or 26. It combines the V8 12.4 engine, the Maglev compiler enabled by default, and a set of built-in features that previously required external packages.

This guide covers what engineering teams need to know in 2026: what Node.js 22 brought, where it sits relative to Node.js 24 and 26, and how to plan upgrades safely for production systems.

Updated October 2026 with the current Node.js release schedule.

Key Takeaways

• ▸Node.js 22 is in Maintenance LTS (security and critical fixes only) and reaches end-of-life on 30 April 2027.
• ▸Node.js 24 is the current Active LTS until 20 October 2026, with security support until 30 April 2028.
• ▸Node.js 26 (released 5 May 2026) is the upcoming LTS, with security support planned until 30 April 2029.
• ▸Node.js 20 reached end-of-life on 30 April 2026 — upgrade any remaining Node.js 20 apps now.
• ▸For new projects, target Node.js 24 or 26; for Node.js 22 apps, plan the next upgrade before April 2027.

What Is Node.js 22 LTS?

Node.js follows a predictable release cadence. Even-numbered releases (18, 20, 22, 24) become Long-Term Support versions: roughly 12 months as the active "Current" and then Active LTS, followed by a maintenance phase before end-of-life. Node.js 22 ships with V8 12.4 (the JavaScript engine from Chrome), libuv improvements for I/O, and a set of APIs that were experimental in Node.js 20 and are now stable.

For production teams, the practical point is stability with a clear support horizon. Applications built on Node.js 22 receive security patches and critical fixes through to its end-of-life on 30 April 2027. That still makes it safe for production today, but with a fixed end date that teams should plan around. Teams upgrading from Node.js 18 or 20 will find Node.js 22 largely compatible, with breaking changes confined to internal APIs and deprecations most applications never touch.

Support Timeline: Node.js 22 vs 24 vs 26

Node.js 22 is no longer the newest LTS. Per the official release schedule and endoflife.date:

So which should you choose? For new projects, target Node.js 24 today, or Node.js 26 once it enters LTS and your hosting provider and dependencies support it. For applications already on Node.js 22, there is no emergency — it is still supported — but schedule the upgrade to Node.js 24 (or 26) well before April 2027. For anything still on Node.js 18 or 20, skip 22 and go straight to Node.js 24, since both 18 and 20 are already end-of-life.

V8 12.4 and the Maglev Compiler

The V8 engine is the foundation of Node.js runtime performance. Node.js 22 ships with V8 12.4, a significant step up from the V8 11.3 in Node.js 20, and — importantly — enables the Maglev compiler by default on supported 64-bit architectures (x64 and arm64).

Maglev is a mid-tier just-in-time compiler that sits between the interpreter and V8's top-tier optimising compiler. Its biggest impact is on short-lived programs — CLIs, build scripts, and serverless functions — where code does not run long enough to reach the top-tier compiler. V8 12.4 also brings WebAssembly garbage-collection improvements that help memory-heavy WASM workloads.

A word of caution on performance claims: real-world gains vary widely by workload, and the honest guidance is to benchmark your own application rather than rely on generic numbers. Where Node.js 22 helps most is high-throughput API servers (which benefit from V8's string and JSON optimisations) and short-lived processes (which benefit from Maglev). These improvements apply automatically on upgrade, with no code changes required.

New Built-In Features

Node.js 22 stabilises several APIs that were experimental in Node.js 20 and introduces built-in capabilities that previously required external packages.

Native Test Runner

The Node.js test runner, introduced experimentally in Node.js 18 and stable since Node.js 20, continues to mature in Node.js 22. It supports parallel test execution, mock functions, spies, code-coverage reporting, and TAP output. It is not a full replacement for the ecosystem tooling around Jest or Vitest, but for simpler testing needs it removes a dependency.

Native Watch Mode

The --watch flag is now stable. Starting your application with node --watch index.js automatically restarts the process when source files change — a built-in alternative to nodemon or ts-node-dev for development workflows.

WebSocket Client by Default

The browser-compatible WebSocket client, previously behind --experimental-websocket, is enabled by default in Node.js 22. Together with the built-in fetch available since Node.js 18, this lets you write more isomorphic code with fewer polyfills.

require() for ES Modules

Node.js 22 adds require() support for fully synchronous ES module graphs. It launched behind the --experimental-require-module flag and has been enabled by default since Node.js 22.12. When the target module is marked as an ES module and contains no top-level await, require() can load it and return its namespace object — easing interop for codebases mixing CommonJS and ESM.

Security Enhancements and Permission Model

Node.js 22 continues to develop the experimental permission model introduced in Node.js 20. The permission model lets you restrict which file-system paths, child processes, and network destinations a Node.js process can access — useful for sandboxing untrusted code or enforcing least-privilege in server applications. It remains experimental, so test thoroughly before relying on it for security-critical use.

Standard security improvements include hardening of the DNS resolution layer, edge-case fixes in the HTTP parser, and OpenSSL updates underpinning TLS and cryptography. These apply automatically on upgrade with no code changes.

ESM and CommonJS Interoperability

One of the most practical improvements for teams maintaining large codebases is better interoperability between ES modules and CommonJS. Node.js 22 reduces the friction of using ESM-only packages from CommonJS contexts — with the new require(ESM) capability noted above — cutting down on wrapper shims and dynamic-import workarounds. For teams gradually migrating from CommonJS to ESM, this is a meaningful quality-of-life gain.

Migration Checklist: Upgrading Your Node.js Version

Before upgrading production systems, work through this checklist.

Update your runtime: change your Dockerfile base image, .nvmrc, or the package.json engines field to your target LTS version (Node.js 24 for most teams in 2026), and run your complete test suite against it before proceeding.

Audit native addons: if your application uses compiled native addons (C++ bindings), confirm builds are available for your target Node.js version. Most major addons publish them, but verify first.

Check for deprecated API usage: run your application with node --pending-deprecation to surface usage of APIs that may be removed in future versions.

Update CI/CD: add the target Node.js version to your GitHub Actions, CircleCI, or other test matrix before removing older versions, so you can catch issues without disrupting existing pipelines.

Monitor after upgrade: in staging, compare memory profiles and request latency against your previous baseline. Newer versions generally run leaner and faster, but unexpected differences can flag version-specific code paths worth investigating — our guide to finding and fixing Node.js memory leaks in production helps here.

Running Node.js 22 in Production in 2026

Several operational considerations apply specifically to Node.js 22.

Container images: official images are on Docker Hub as node:22, node:22-slim, and node:22-alpine. The alpine variant gives the smallest image. Pin a specific patch version (for example node:22.x.x) rather than the floating node:22 tag for reproducible production builds.

Serverless: AWS Lambda, Google Cloud Run, and Azure Functions all support Node.js 22 runtimes. The Maglev compiler's faster start-up for short-lived processes is particularly valuable for serverless workloads with variable traffic.

Process management: PM2 fully supports Node.js 22 and provides clustering, zero-downtime restarts, and memory monitoring for non-containerised deployments; for containers, let your orchestrator manage processes.

How PapaSiddhi Can Help

PapaSiddhi Technologies provides web development services and dedicated Node.js developers — available to clients in the USA, UK and other markets — for runtime upgrades, performance audits and new builds. If you are building with React on top of Node.js, see our Next.js App Router production guide. Contact our team to plan your Node.js upgrade.