Node.js 7 min read

Node.js 26 LTS upgrade: a plan for business apps and APIs

Node.js 26 became LTS on 28 October 2026. A practical Node.js 26 LTS upgrade plan: what changed, what breaks, how to test on both versions, and fixes for the problems teams hit.

Crest Design
Planning a Node.js 26 LTS upgrade for a business web app or API.

If your website, store integration or internal tool runs on Node.js, this is for you. On 28 October 2026 Node.js 26 (codename "Lithium") moved into Active Long Term Support with release 26.13.0. That makes a Node.js 26 LTS upgrade the sensible next step for most production apps, and it starts a clock for anything still on Node.js 22. Below we explain what actually changed, what tends to break, and the upgrade plan we follow on client APIs and Next.js sites.

The problem: your app runs on a version with an end date

Most business owners never think about the Node.js version behind their site. It was picked when the project was built, and it quietly keeps working. The trouble is that every Node.js release line has an end-of-life date, and after that it stops getting security fixes.

Here is where things stand in November 2026, from the official release schedule:

Release line Status now End of life
Node.js 22 "Jod" Maintenance only 30 April 2027
Node.js 24 "Krypton" Maintenance since October 2026 30 April 2028
Node.js 26 "Lithium" Active LTS since 28 October 2026 30 April 2029
Node.js 27 Alpha, not for production LTS planned for October 2027

If you're on Node.js 22, the deadline is close enough that it belongs in your next quarter's plan. If you're on 24, you're safe for now, but new features and performance work land on 26 first. And if a developer tells you your app is on Node.js 20 or older, it's already past end of life and should move first.

Timeline of Node.js 22, 24, 26 and 27 support phases, showing Node.js 26 entering LTS in October 2026 and running to April 2029.
Where each Node.js release line stands after Node.js 26 became LTS (dates from the Node.js release schedule).

How Node.js releases and LTS actually work

A Node.js major version spends its first six months as "Current". That period is for library authors and early adopters to find problems. Once that window closes, the project promotes it to LTS, and from then on it only gets carefully backported fixes. That's why the 26.13.0 release notes say nothing changed apart from the LTS label: the code you'd run is the same as 26.12.1, it's just now the line the project commits to supporting.

The breaking changes all arrived back in April and May 2026 with Node.js 26.0.0. The ones we see matter in real projects are:

  • Old stream modules removed. _stream_readable, _stream_writable, _stream_duplex, _stream_transform, _stream_passthrough and _stream_wrap are gone. Your own code rarely uses them, but older dependencies sometimes do.
  • res.writeHeader() removed. Use res.writeHead(). This turns up in older custom HTTP servers and middleware.
  • module.register() is runtime-deprecated and --experimental-transform-types is removed, which affects some custom loaders and TypeScript setups.
  • Native add-ons need rebuilding. The add-on ABI version changed, so packages with compiled code (image processing, some database drivers, password hashing) must be reinstalled against Node.js 26.
  • Linux binaries link against libatomic (since Node.js 25), which some slim container images don't include.

There's also good news. Node.js 26 ships V8 14.6 and turns on the Temporal API by default, a much saner way to handle dates, time zones and durations than Date. It's worth knowing about for booking, scheduling and reporting features, but you don't need to adopt it to upgrade.

One more change affects planning beyond this year. Node.js 26 is the last line under the old odd/even model. From Node.js 27, there's one major release a year, every major becomes LTS, and a six-month Alpha channel replaces the odd-numbered releases. In practice, that means one predictable upgrade each autumn.

How to run a Node.js 26 LTS upgrade safely

We treat a runtime upgrade as its own small project, not something slipped in alongside other work. Here's the order we follow.

Five-step Node.js 26 upgrade flow: inventory, scan, test both versions, staging, then production with a rollback ready.
The order we follow when moving a Node.js app or API to a new LTS line.

1. Inventory every place Node.js runs

The web server is the obvious one. The ones people forget are the CI pipeline, the build step on your host, scheduled jobs, serverless functions, Docker base images and developer laptops. Write down where the version is set in each: .nvmrc, the engines field in package.json, the Dockerfile FROM line, or a runtime setting in your hosting dashboard. Also confirm your host offers Node.js 26 as a runtime before you plan dates around it.

2. Scan for removed APIs and compiled packages

Run your test suite with deprecation tracing on, and search your code and dependencies for the removed APIs:

# show where deprecated APIs are called during tests
NODE_OPTIONS=--trace-deprecation npm test

# look for APIs removed in Node.js 26
grep -rnE "_stream_(readable|writable|duplex|transform|passthrough|wrap)|\.writeHeader\(" src node_modules --include=*.js | head -50

# list packages with native (compiled) code
find node_modules -name "*.node" -not -path "*/test/*"

Any hit inside node_modules usually means a dependency needs updating, not that you need to patch it yourself.

3. Test on both versions at once

Run CI on your current line and on Node.js 26 side by side until both pass. This GitHub Actions job goes in .github/workflows/test.yml; change 24 to whatever version you run today:

name: test
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        node: [24, 26]
    steps:
      - uses: actions/checkout@v5
      - uses: actions/setup-node@v5
        with:
          node-version: ${{ matrix.node }}
          cache: npm
      - run: npm ci
      - run: npm test

When both pass, set "engines": { "node": ">=26" } in package.json and update .nvmrc to 26 so every machine agrees.

4. Stage it with real traffic patterns

Deploy to staging and exercise the parts tests miss: webhooks from your store or CRM, file uploads, scheduled jobs, PDF or image generation, and anything that talks to a payment provider. Watch memory and response times for a day if you can.

5. Go live with a rollback ready

Keep the previous image or runtime setting one click away. Most hosts let you redeploy the last build, but check that the rollback also restores the old Node.js version, not just the old code.

What we've learned from runtime upgrades

Most upgrades between LTS lines are uneventful when the dependencies are current. The painful ones are apps that skipped several years of package updates, because the runtime upgrade then drags a pile of major dependency upgrades with it. If that's you, budget for the dependency work separately and be honest about it.

We'd move straight from 22 to 26 rather than stopping at 24. Both jumps involve similar testing effort, and 26 gives you the longer runway. The exception is a host or platform that doesn't offer 26 yet; then 24 is a perfectly sound interim step.

Troubleshooting

  • Symptom: the app crashes on start with "Cannot find module '_stream_readable'". Cause: an old dependency, often a stream or HTTP helper, requires a removed internal module. Fix: run npm ls to find which package pulls it in and update it, or replace it with the modern node:stream equivalent.
  • Symptom: "was compiled against a different Node.js version" or "NODE_MODULE_VERSION" errors. Cause: a native add-on built for the old version. Fix: delete node_modules and reinstall with npm ci on Node.js 26; don't copy node_modules between images.
  • Symptom: the node binary fails in a container with an error about libatomic.so.1. Cause: a slim Linux base image missing the library. Fix: install it in the Dockerfile (for example libatomic1 on Debian-based images) or use the official Node.js 26 image.
  • Symptom: "res.writeHeader is not a function" on some requests. Cause: older custom middleware. Fix: replace the call with res.writeHead().
  • Symptom: CI passes but production still reports the old version. Cause: the hosting dashboard or Dockerfile pins its own version. Fix: log process.version at start-up and check it after each deploy.

Questions people ask

Do I have to upgrade to Node.js 26 right now?

Not if you're on Node.js 24, which is supported until April 2028. If you're on 22, plan the move well before its end of life in April 2027 so you aren't upgrading under pressure.

Will the upgrade change how my website looks or behaves?

It shouldn't. A runtime upgrade is invisible to visitors when it's done properly. Problems show up in back-end behavior, such as a webhook or image step failing, which is why staging tests matter.

Should we test on the Node.js 27 Alpha?

Only if you maintain a library or have a long-lived product with good test coverage. For most business apps, waiting for 27 to reach LTS in October 2027 is fine.

Why it matters for your business

An unsupported runtime is a quiet risk: everything works until a security issue is found that will never be patched on your version. Planning a Node.js 26 LTS upgrade now keeps your APIs, integrations and storefront builds on a supported footing until 2029, and it's far cheaper as planned work than as an emergency. If your Node.js app also handles store or CRM events, our guide to building reliable webhook receivers in Node.js pairs well with this upgrade. Running Next.js? Read our Next.js 16.4 upgrade plan and schedule it as a separate release. For the wider picture, our website security checklist for small businesses covers patching beyond the runtime.

Quick checklist: list where Node.js runs, scan for removed APIs and native add-ons, test on both versions in CI, stage with real traffic, then go live with a rollback ready.

If you'd like a hand planning or running the move, our Node.js development team is happy to talk it through with you.

(over to you)

Planning a build like this?

Tell us what you're building and we'll come back with ideas and next steps.