Node.js 22 reaches end of life on April 30, 2027, according to the official Node.js release schedule. After that date the project stops shipping security patches for it. Plan the move to Node.js 24 LTS, supported until April 30, 2028: it is a single major version, the Node.js project publishes an official migration guide with codemods for it, and doing it while 22 is still patched lets you test, canary and roll back without a security clock running.
Source for every date in this table: the official Node.js release calendar (checked November 21, 2026).
Node 22 moved from Active LTS into maintenance on October 21, 2025. In maintenance, the project still releases fixes; the latest Node 22 build at the time of writing is 22.23.5, published November 11, 2026, per the v22 changelog. That is the window to use. Node 24 is the natural landing spot because the project wrote a dedicated migration page for v22 to v24 covering exactly this hop and says Node 24 gets updates through the end of April 2028. Node 26 became Active LTS in October 2026 and runs to April 2029; if your release train is long, evaluate it, but expect fewer official migration notes for that jump today.
Once April 30, 2027 passes, Node 22 joins Node 20 on the unsupported list. The Node.js end-of-life policy spells out the consequence: an EOL line "will no longer receive updates, including security patches." Fixes that land in Node 24 or Node 26 afterward will not be backported to 22.
Two knock-on effects from that same official page are worth planning around now. First, popular npm packages tend to drop support for EOL Node lines over time, so after the date you can expect library upgrades to start requiring a newer runtime. Second, the project warns about compliance directly, and its previous releases page says to keep production on a line that is still in long-term support.
For SOC 2, criterion CC7.1 asks companies to detect and manage vulnerabilities. Having a dated upgrade plan for a runtime that is approaching end of life is a much easier story to tell than explaining why it slipped past. We unpack that in SOC 2 for AI-assisted codebases. Customer security questionnaires usually ask the same thing in plainer words: which runtimes do you run, and are they supported? Before April 2027 the honest answer for Node 22 is yes, with a scheduled replacement. You want to keep it that way.
The practical point: nothing breaks on May 1, 2027. What changes is that every later Node security release becomes a decision you cannot act on for Node 22 workloads. Moving early means the cutover happens when your team picks the date.
Planning ahead lets you do a careful inventory instead of a panicked one. Build a register of every Node 22 workload, then a second list of the code patterns Node 24 will reject. Both are cheap now.
Not every Node 22 workload carries the same weight. Tag each entry with three questions. Does it hold a compiled addon? Does it talk TLS to anything you do not control? Does it depend on request context for logging, auth or billing? Workloads that answer no to all three are your early wins and make good first rings. Workloads that answer yes to two or more deserve a named owner and a spike in CI right away, because their blockers usually sit with a vendor or a partner, and those conversations take the longest to schedule.
Also record who decides. Some Node 22 runtimes live in accounts owned by another team, a vendor or an acquired business unit. Knowing whose approval each cutover needs, before April 2027 starts to feel close, prevents the most common reason planned upgrades slip: everything is ready except the sign-off.
Our free EOL deadline radar handles the first list for you: paste a manifest, Dockerfile or CI file and it returns a dated report showing Node 22's April 30, 2027 end of life alongside every other runtime it finds. Attach the report to the planning ticket so the deadline is visible to whoever owns the budget.
This is a one-major hop, so the list is shorter than a two-major catch-up, but several changes are behavioral rather than syntactic. The items below come from the official 22 to 24 guide, the Node 24.0.0 release notes, the v24 changelog and the deprecations reference.
The bundled crypto library jumps to OpenSSL 3.5, and its default security level of 2 refuses short keys: below 2048 bits for RSA, DSA or DH, below 224 bits for elliptic curves, and anything using RC4. The v24 changelog notes OpenSSL 3.5 is supported until April 2030, beyond Node 24's own window. This is the change most likely to fail at runtime rather than in tests, because it depends on who you talk to: an old internal CA, a partner SFTP gateway, a vendor API pinned to legacy ciphers.
DEP0169 now warns when url.parse() is called from your own code (calls from inside node_modules are excluded). The deprecations reference also places url.format with a string and url.resolve() under the same entry, and adds that url.parse() flaws do not get CVEs at all. Replace it with new URL() from the WHATWG standard. Do it before the upgrade so the warnings do not hide anything new.
Node 24.0.0 removes dirent.path (use dirent.parentPath), removes calling fs.truncate with a file descriptor (use fs.ftruncate), and removes tls.createSecurePair (use TLSSocket). process.assert went end-of-life in Node 23. The guide lists an official codemod for each, run as npx codemod run @nodejs/dirent-path-to-parent-path, @nodejs/fs-truncate-fd-deprecation, @nodejs/tls-create-secure-pair-to-tls-socket and @nodejs/process-assert-to-node-assert. A separate codemod, @nodejs/fs-access-mode-constants, moves F_OK and friends to fs.constants.
Node 24 makes AsyncLocalStorage use AsyncContextFrame by default. The release notes describe it as a more efficient implementation of async context tracking. If you rely on request-scoped context for logging, tracing or tenant isolation, or run an APM agent that hooks into async context, verify context propagation in staging, especially across custom thenables, event emitters and worker pools.
The built-in test runner now waits for subtests automatically, and the 24.0.0 commit list removes the promise previously returned by t.test(). Suites that awaited subtests explicitly or relied on the old return value need a look. Separately, Node 24 removed HTTP/2 priority signaling, following its deprecation in RFC 9113; the http2-priority-signaling codemod strips the option and stream.priority() calls.
Node 24 moves to V8 13.6. The official guide warns that addons linking against V8 APIs may need updates and may require C++20 where C++17 was enough. It recommends Node-API to reduce rebuild churn. Check that every compiled dependency publishes Node 24 builds, or plan to replace it.
If you still ship to 32-bit hardware, note that official downloads stopped for Windows x86 at Node 23 and for armv7 Linux at Node 24, where armv7 drops to experimental. Apple machines need at least macOS 13.5; on Linux the glibc 2.28 floor is unchanged. Building from source needs gcc 12.2 or later on Linux, Xcode 16.1 or later on macOS, and ClangCL on Windows, since Node 24 removed MSVC support. npm 11 now comes in the box, and the permission model flag lost its experimental prefix (it is simply --permission), so scripts pinned to npm 10 or the old flag name need edits.
With the deadline still ahead, the plan can be deliberate: one hop, proven in CI first, rolled out in rings, with Node 22 kept live as the fallback until each service has earned its way off it. Schedule cutover well before April 2027 so a slipped phase still lands inside the support window.
Convert both lists from the exposure section into a tracked register: workload, owner, Node 22 pin location, compiled dependencies, TLS peers and flagged code patterns. Capture a baseline for each service on Node 22 today: error rate, latency percentiles, memory, cold start time for serverless, and how many deprecation warnings it already logs.
Start with Node 24 as an advisory CI job beside Node 22, then make it blocking once a service passes. Apply each official codemod in its own pull request. Run with --trace-deprecation and --throw-deprecation in a test job so warnings fail loudly. Stand up a staging TLS test that connects to every external peer from a Node 24 container. Verify AsyncLocalStorage context in a trace-heavy path end to end.
Ship Node 24 images in rings: internal tools and batch workers first, then services with good rollback paths, then customer-facing APIs behind a canary. For serverless functions, publish a new version on the Node 24 runtime and shift a weighted alias. Hold each ring until it matches the Node 22 baseline.
Flip what is left once the canary is clean through at least one normal release. Keep the last Node 22 image or function version deployable as the rollback target until well after cutover. Because this hop has no forced data migration, rollback stays an image or alias change, so keep it that way by separating any unrelated refactors.
Remove Node 22 from CI, base images and version pins, and raise engines to >=24. Close out the flagged-pattern list. Put Node 24's April 30, 2028 end of life into the same register so the next hop is planned from a known date, not discovered.
A planned 22 to 24 hop is lighter than a rescue, yet it touches every repo. Typical staffing: a lead accountable for the register and the date, application engineers handling codemods, async context and test-runner fixes, plus a platform specialist for images, pipelines, canaries and function aliases. If you have many TLS peers or a regulated environment, add someone with security engineering background to own the certificate audit.
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. Once you say go, engineers can typically start in under two weeks, which leaves room to finish well ahead of April 2027. Ryz engineers work on your team, reporting to your leads. Bring in Node.js developers, or a dedicated AI pod team if the same people will also build on top of the upgraded stack, and scope your team with us.
When we are not the right fit: if you only need an hourly freelancer to run codemods, or you want follow-the-sun support across Europe and Asia, other models will serve you better.
Until April 30, 2027, Node.js 22 is a supported maintenance line and still receives security releases. After that date it gets no more fixes from the project, so new vulnerabilities stay open on it. The safe position is to finish moving to a supported line before the date, while 22 can still act as a patched fallback.
Node.js 24 LTS, supported until April 30, 2028. It is one major version away, and the Node.js project publishes an official 22 to 24 migration guide with codemods. Node 26 is Active LTS until a longer April 2029 end of life, so teams with long release cycles may want to evaluate it as well.
The drivers are the number of Node 22 workloads, compiled dependencies without Node 24 builds, TLS peers with weak keys, reliance on AsyncLocalStorage or APM agents, test coverage, and how many teams must approve rollouts. Building the register first gives you a grounded answer for your own systems.
The Node.js project lists HeroDevs, NodeSource and TuxCare as partners offering commercial security support for end-of-life Node.js versions through the OpenJS Foundation Ecosystem Sustainability Program. The project calls this a temporary solution. With Node 22 still supported today, planning the upgrade is usually simpler than buying time later.
Engineers from Ryz start at $7,000 a month per person, with a published range up to $15,000, mostly mid-level to senior. We quote per team, and the total is team size times duration times the monthly rate. Before any work begins you receive a plan, a price and the names of the 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.