The Node.js Release Schedule Is Changing: One LTS a Year, Starting Now

Hamza Fazal, Founder, DEESUHamza FazalFounder, DEESU8 min readCloud & DevOps

On October 28, 2026, Node.js 26 transitions to Active LTS — and on the same day, something quieter but more consequential happens: the Node.js 27 alpha channel opens under a completely new release model. This is the change that's been working its way through backend and DevOps circles over the last few weeks, because the Node.js release schedule that every team has planned upgrades around for the better part of a decade is being replaced. Node.js 26 is the last release line under the old rules. From version 27 onward, Node.js ships one major release a year instead of two, and every release becomes an LTS. If you run Node anywhere — a backend API, a build pipeline, a container base image — the new Node.js release schedule is worth understanding now, three weeks before it actually takes effect, rather than the next time you go to bump a version and find the rules have moved.

What actually changes on October 28

Two things happen at once. Node.js 26, which released on May 5, 2026, moves from its Current phase into Active LTS — the point at which it becomes the version production deployments are expected to standardize on, with 18 months of bug fixes and security patches ahead of it before it drops to maintenance. That part is routine; every even-numbered Node release has followed this path for years.

The non-routine part is that the Node.js 27 alpha channel opens the same day, and it does so under the schedule the project laid out in its "Evolving the Node.js Release Schedule" announcement. Starting with 27.x, Node.js moves from two major releases a year to one: a single new major each April, promoted to LTS each October. Node.js 26 is explicitly the last release line built under the current twice-a-year model, which makes this month the actual hinge point rather than a future date to bookmark.

The end of odd versus even

The detail that trips up the most people is the retirement of the odd/even convention. Under the old Node.js release schedule, even-numbered versions (18, 20, 22, 24, 26) became LTS and were the ones you shipped to production, while odd-numbered versions (19, 21, 23, 25) were short-lived Current-only releases that never reached LTS and were meant for testing upcoming changes, not for running real workloads. A generation of deployment advice, Dockerfile comments, and CI configs encodes that rule as a reflex: if it's odd, don't ship it.

That reflex stops being correct with Node.js 27. In the new model there is no odd/even distinction, because there's only one release a year and every release becomes LTS. Node.js 27 — an odd number — will be a fully supported long-term release. Any automation or team habit that silently skips odd majors will, starting next year, skip a version it was supposed to adopt. This is the kind of assumption that doesn't throw an error; it just quietly leaves you a year behind without anyone deciding to.

What Node.js 26 itself brings to the table

Since 26 is the version you'll actually be standardizing on when it hits LTS this month, it's worth knowing what the upgrade carries. The headline runtime change is V8 14.6, which brings the newer JavaScript language and performance work that engine version includes. The most visible platform change is that the Temporal API — the modern replacement for JavaScript's long-criticized Date object — is enabled by default rather than hidden behind a flag, which is a genuinely useful shift for any code doing date and time math, historically one of the most bug-prone corners of a JavaScript codebase.

Node.js 26 also continues the project's pattern of removing APIs that have been deprecated across multiple major versions. That's the part most likely to bite on upgrade: code leaning on a long-deprecated API that still happened to work on Node 24 can stop working on 26. It's rarely a large fix, but it's the reason you test the jump rather than assuming an LTS-to-LTS move is a no-op — the whole point of a longer gap between releases is that each jump carries more accumulated change than the one before it did.

What a slower cadence actually changes for upgrade planning

It's tempting to read "fewer releases" as "less to keep up with," and for teams that always rode the LTS line, the day-to-day rhythm barely changes — you still adopt one LTS, run it until the next, and upgrade roughly once a year. What changes is the size of each jump. One major a year means a larger diff of engine upgrades, API removals, and behavioral changes accumulates behind each release, so the annual upgrade is a more substantial piece of work than a six-month hop was, even though it happens half as often. Budgeting a real testing pass for it, rather than treating it as a version-string bump, matters more under the new Node.js release schedule than it did under the old one.

The concrete failure mode to guard against is anything pinned to a specific major instead of tracking LTS symbolically. CI base images and Dockerfiles that hardcode node:24 or node:26 don't follow the schedule — they sit still until a human changes them, and the gap between what you're running and what's supported widens silently. Pinning to the lts/* alias (or node:lts for images) lets the schedule move you forward on its own cadence instead of relying on someone remembering the new promotion dates. That's doubly worth doing now that the promotion rhythm itself is changing from twice a year to once.

An upgrade routine that survives the new schedule

A yearly cadence makes the upgrade a predictable project instead of a series of small surprises. A calendar entry and a short checklist are most of what you need.

  1. Put the date in the calendar. Add the LTS promotion each October as a recurring task for the person who owns your runtime.
  2. Run your tests on the incoming version early, while it is still Current or in preview, so failures arrive as warnings.
  3. Read the deprecation and removal notes for the version you are jumping to, and search your code for each removed API.
  4. Upgrade build tooling and dependencies together, because native modules often need a compatible release.
  5. Roll out gradually: development, staging, then a small share of production, with monitoring on error rates and latency.
  6. Record the decision so the next person knows which version you run and why.
Where the version is setWhat to do
Dockerfile or base imagePrefer node:lts where an exact pin is not required
CI configurationUse the lts/* alias in setup actions
.nvmrc or engines in package.jsonReference the current LTS and update it on a schedule
Serverless runtime settingsChoose the newest supported LTS runtime and track its end of support
Documentation and onboardingRemove any "skip odd versions" rule
Places a hardcoded Node.js version tends to hide

What we'd actually recommend

If you're still on Node 24 or earlier, plan the move to Node.js 26 around its October 28 LTS promotion rather than rushing onto it as a Current release — landing on it right as it stabilizes gives you the longest supported runway on the last version released under the old model. Before you do, run your test suite against 26 specifically to catch anything relying on an API that 26 removed, and take the opportunity to check whether any date-handling code benefits from Temporal now being on by default.

Audit your CI configs, Dockerfiles, and deployment manifests for hardcoded major versions, and move them to the lts/* or node:lts aliases wherever a pinned exact version isn't a hard requirement. This is the single change that makes the new once-a-year Node.js release schedule work for you automatically instead of becoming a recurring manual chore you have to remember.

And wherever your tooling, documentation, or team knowledge encodes the old "skip odd versions" rule — a comment, a lint rule, a mental model in code review — flag it now. Node.js 27 next April will be the first odd-numbered LTS, and the teams that get caught by this will be the ones who automated the old assumption so thoroughly that no one remembers it's there. Writing down that the odd/even rule ends with 26 is cheap today and saves a confused debugging session next year.

Frequently asked questions

Under the announced schedule, every release from 27 onward becomes LTS, so the odd and even distinction no longer applies.

If you run production, plan the move around the LTS promotion rather than adopting it as a Current release, and test your suite on 26 beforehand.

Use node:lts or the lts/* alias where you can, so you follow the supported line automatically. Pin an exact version only when you have a specific reason.

Fewer upgrades, but each is larger. Allow time for testing, dependency updates and rollout.

On the official Node.js releases page, which lists each version's phases and end-of-life dates.

Sources

ShareLinkedInX
Hamza Fazal, Founder, DEESU

Written by

Hamza Fazal

Founder, DEESU

Muhammad Hamza Fazal is the Founder of DEESU. An Android and full-stack web developer and digital marketer based in Islamabad, he founded DEESU in May 2022 and leads its engineering operations, product strategy, and client software delivery.

More from Hamza

Need help with this?

Reply within 1 business day

Tell us what you're building.

Send the problem, not a polished brief. We'll tell you what it actually takes to ship it: stack, timeline and cost, before you commit to anything.