Skip to content

Next.js security release on November 3: what to do before and after

Update/ 15 min read

Next.js ships a security release on November 3 for seven medium vulnerabilities. What to prepare today, how to upgrade with npm, pnpm, yarn or bun, and how to roll back.

  • Next.js
  • Security
In this article (7)
  1. What the Next.js security release covers, and when
  2. Before the patch: production version, tests and a ready branch
  3. Release day: read the advisories, upgrade, test, deploy
  4. How to upgrade without breaking anything (npm, pnpm, lockfile)
  5. Common mistakes
  6. Frequently asked questions
  7. Checklist

The Next.js security release lands on November 3, 2026 and fixes seven medium-severity vulnerabilities. The patched versions and CVEs are published that day, not before. Everything else you can do today: write down the version running in production, commit the lockfile, get tests green and rehearse a rollback.

This is a pre-announcement. We wrote it on November 2, the day before the release, using only what Next.js has published: no made-up version numbers or CVEs, and we will update this article once the advisories are out. If your project is still on Next.js 14, read why Next 14 has no patch for the October RCEs first.

What the Next.js security release covers, and when

On October 27, 2026, Jamiboy Mohammad and Sebastian Silbermann posted the advance notice for the November security release on the official blog. It says four things:

  • The release ships on Tuesday, November 3, 2026, and the notice exists so teams can plan upgrades before patches are published.
  • It addresses seven medium vulnerabilities in Next.js.
  • The full advisories are published alongside the release: impact, affected versions and upgrade instructions.
  • The team recommends upgrading to a patched version once the release is available.

What it leaves out matters as much: no version numbers, no CVEs, no time of day, and no word on which release lines (16.x, 15.x) get a new version. Any November 3 version number you see today is a guess.

This rhythm started on July 13, when the team announced a formal security release program: roughly once a month, an advance notice with the expected timeline and the highest severity it covers. Per that post, the lead time also lets them coordinate with hosting providers on mitigations, such as firewall rules, for apps that have not been patched yet. Urgent issues, or ones already exploited in the wild, still ship as ad-hoc patches. Here is the 2026 record from the Next.js security news page:

NoticeReleaseVersionsWhat happened
Jul 13Jul 2016.2.11 · 15.5.21First scheduled release
Aug 20Aug 2516.3.3 · 15.5.24Announced for Aug 26; moved up a day for a second critical vulnerability
Sep 22Sep 2216.3.6 · 15.5.26Out of band, for a critical upstream issue
Sep 23Sep 3016.3.8 · 15.5.27Two fixes postponed; 16.3.7 shipped on Sep 29 without the security fixes
Oct 8Oct 1416.4.1 · 15.5.28Out of band; included the two postponed fixes
Oct 27Nov 3Not publishedSeven medium vulnerabilities

Two lessons come out of that table. Dates move: in August, an updated notice pulled the release forward by a day. And scope changes: the September notice got two notes, one saying 16.3.7 did not include the fixes and one postponing two of them. The versions that count are the ones in the release post, not the notice.

from the notice to your deploy: the November releaseOct 14last patch: 16.4.1 and 15.5.28out-of-band updateOct 27notice: seven medium vulnerabilitiesno versions or CVEs yetNov 216.4.4 ships: bug fixes onlynot the security releaseNov 3security release + GHSA/CVE advisoriesimpact, affected versions, upgrade stepsyour deploybranch · build · smoke test · productionthen check the version actually runningthe notice comes 6-7 days early; versions on the daydates from nextjs.org/blog/security and the v16.4.4 GitHub release notes

Scroll the figure sideways to see all of it

It happened again today. Next.js 16.4.4 shipped on November 2 and is the latest tag on npm, but its release notes say it is a bug-fix backport and that the November security release is published the next day. Upgrading to 16.4.4 today is not applying the security release.

Which lines get patches? The support policy puts 16.x in Active LTS and 15.x in Maintenance LTS, and it extended the latter: security releases for Next.js 15 continue through January 31, 2027. 14.x and 13.x are unsupported; the policy only says that in rare circumstances, depending on severity, versions outside LTS may be patched. Every release in the table shipped one 16.x and one 15.x version, but the November notice does not confirm that yet.

Before the patch: production version, tests and a ready branch

Everything in this section can be done today. On release day, the only thing missing should be the version number.

Write down the version that is running

These are the commands we ran in a test project on Next.js 15.5.27, Node 22.22.3 and npm 11.11.1, with their real output (project path shortened):

$ npm ls next
npm-demo@1.0.0 C:\…\npm-demo
`-- next@15.5.27

$ npx next --version
Next.js v15.5.27
$ npm view next dist-tags.latest
16.4.4
$ npm view next dist-tags.backport
15.5.28
  1. npm ls next shows the version installed in node_modules and what depends on it. In a monorepo it can appear more than once, and every copy counts.
  2. npx next --version prints the version the Next.js CLI runs (-v or --version, per the CLI reference). Run it where your production build runs too, not only on your laptop.
  3. npm view next dist-tags.latest asks the registry: today latest is 16.4.4, the bug-fix-only release.
  4. npm view next dist-tags.backport returns 15.5.28 today, the newest 15.x. If you are on 15, that is your reference point, not latest.

What matters is the version of the build in production, not the one on your branch: note the deployed commit and its lockfile. And do not go by the warning in next info. With 15.5.28 installed, the patched version from October 14, it printed An outdated version detected (latest is 16.4.4) for us, because it compares against latest, not your release line.

Lockfile in git, and CI that respects it

The lockfile (package-lock.json, pnpm-lock.yaml, yarn.lock or bun.lock) is what pins the exact version you deploy. It has to be committed, and CI has to install from it without rewriting it. With npm that is npm ci: per the npm ci documentation, it requires a lockfile, exits with an error if it does not match package.json, and never writes to either. If your CI runs npm install today, change it before release day, not on it.

Tests that cover what tends to break

Check that the build and the test suite pass today on your main branch. If they already fail before the patch, on release day you will not know what broke what. Then look at the areas the 2026 advisories touched: Image Optimization (/_next/image), Server Actions, middleware or proxy, rewrites() and caching (ISR, use cache). If you use any of them, have a test or a smoke-test step that goes through it. For a store, the model is the checkout smoke test before Black Friday: the same steps work after every patch.

A branch and a rehearsed rollback

Pick the branch name (for example chore/next-security-2026-11) and who approves the merge. Then rehearse the rollback: how do you redeploy the previous build on your platform? If you have never done it, do it today with a low-risk build. If AI agents work in the repo, keep the change on its own branch and in its own commit, as in the git workflow for AI agents.

security release readiness checklistbefore · todayproduction version written downlockfile in git, npm ci in CIbuild and tests green todaysmoke test ready to runrollback rehearsed (prior build)release day · Nov 3read the post and GHSA advisoriesaffected? your line's versionupgrade on a branch, read the diffbuild, tests, smoke on a previewdeploy, then check the versionthe left column can be done todayon release day, the only missing piece is the advisory's version

Scroll the figure sideways to see all of it

Release day: read the advisories, upgrade, test, deploy

When the release post goes up, this is the order:

  1. Read the post and every advisory. The post appears on nextjs.org/blog/security and links one GHSA advisory (and a CVE, when there is one) per vulnerability. Each advisory says who is affected. In the September release, for example, one advisory did not affect apps without images.remotePatterns, another did not affect apps deployed on Vercel, and another did not affect apps built with Turbopack.
  2. Pick the version for your line. On 16.x, the 16 version in the post; on 15.x, the 15 one. Do not change major versions on release day: that is a migration, with its own branch and its own testing.
  3. Upgrade on the branch and read the lockfile diff before you commit.
  4. Run the build, the tests and the smoke test on a preview or staging deployment, with production environment variables.
  5. Deploy and verify the version running in production, the same way you noted it before.
  6. Re-read the post later that day. In September the notice got new notes the day before the release and on the day itself.

A hosting mitigation such as a firewall rule does not replace the upgrade. The security program describes it as protection for apps that have not been patched yet, not as an alternative to patching.

How to upgrade without breaking anything (npm, pnpm, lockfile)

This is the full flow we ran with npm, from 15.5.27 to 15.5.28, the patched version from October 14. On November 3 only the number changes: use the one the post gives for your line. Build and server output trimmed:

$ git switch -c chore/next-security-2026-11
Switched to a new branch 'chore/next-security-2026-11'
$ npm install next@15.5.28 --no-audit --no-fund

changed 3 packages in 24s
$ git diff --stat
 package-lock.json | 82 +++++++++++++++++++++++++++----------------------------
 package.json      |  2 +-
 2 files changed, 42 insertions(+), 42 deletions(-)
$ npm run build
   ▲ Next.js 15.5.28
 ✓ Compiled successfully in 5.0s
$ npx next start -p 3123
 ✓ Ready in 592ms
$ curl -s -o /dev/null -w "%{http_code}\n" http://localhost:3123/
200
$ git commit -am "chore(deps): next 15.5.28"
[chore/next-security-2026-11 acf989d] chore(deps): next 15.5.28
 2 files changed, 42 insertions(+), 42 deletions(-)
  1. git switch -c creates the patch branch from main.
  2. npm install next@15.5.28 installs that exact version and rewrites package.json and package-lock.json. --no-audit and --no-fund only turn off the audit and the funding messages. The 3 packages that change on disk are next, @next/env and the @next/swc binary for your platform.
  3. git diff --stat shows two files. In the lockfile, 10 entries move: next, @next/env and the eight @next/swc-* binaries. If the diff touches hundreds of packages, someone regenerated the lockfile: stop and look.
  4. npm run build runs the production build; its first line confirms the new version.
  5. npx next start starts the server and, in a second terminal, curl checks that the page answers 200. That is the minimum smoke test; yours should walk your real flows.
  6. git commit puts the patch in a commit of its own, easy to revert.

Watch the range. npm saved "next": "^15.5.28", with its default ^; pnpm 10.2.0 saved an exact "15.5.28" in our test. Either way, the lockfile is what pins the version. With a ^, an install without the lockfile can move to any newer 15.x, and the support policy warns that Maintenance LTS updates land as semver-minor releases even if they are breaking changes. Hence: the exact version from the post, the lockfile in git and a frozen install in CI.

If you use eslint-config-next, move it to the same version: create-next-app writes next and eslint-config-next with the same number. npm install next@15.5.28 eslint-config-next@15.5.28 updates both and keeps the config in devDependencies, which we checked.

The same steps in each package manager. We ran npm and pnpm; the Yarn and Bun commands come from their docs:

Package managerCheck the versionUpgradeInstall in CILockfile
npmnpm ls nextnpm install next@<v>npm cipackage-lock.json
pnpmpnpm list next or pnpm why nextpnpm add next@<v>pnpm install --frozen-lockfile (on by default in CI)pnpm-lock.yaml
Yarn 2+yarn why nextyarn add next@<v>yarn install --immutable (default on CI)yarn.lock
Yarn 1yarn why nextyarn add next@<v>yarn install --frozen-lockfileyarn.lock
Bunbun why nextbun add next@<v>bun install --frozen-lockfile or bun cibun.lock

Sources: pnpm install (--frozen-lockfile is true in CI when a lockfile exists), yarn install, yarn install in Yarn 1 and bun install, which does not freeze the lockfile on CI by itself: pass the flag or use bun ci.

Next.js patch commands, by package managertoolcheckupdateCI, from the lockfilenpmnpm ls nextnpm install next@<v>npm cipackage-lock.jsonpnpmpnpm list nextpnpm add next@<v>pnpm install --frozen-lockfilepnpm-lock.yamlyarnyarn why nextyarn add next@<v>yarn install --immutableyarn.lockbunbun why nextbun add next@<v>bun install --frozen-lockfilebun.lockCI installs from the lockfile, never rewrites it<v> = the version the advisory gives for your line · yarn: Yarn 2 and later

Scroll the figure sideways to see all of it

Also check the packages the advisory names

A fix can depend on another package's version. October's Image Optimization advisory (GHSA-2464-fhr4-w9xw) asks for sharp 0.35.5 or later, and says upgrading Next.js makes package managers provide a fixed version. But next@15.5.28 declares sharp as an optional dependency with the range ^0.34.3 || ^0.35.5, and with an existing lockfile that does not always happen. We tested it on the lockfile alone, starting from next 15.5.20:

$ npm ls sharp --package-lock-only
sharp-demo@ C:\…\sharp-npm2
`-- next@15.5.20
  `-- sharp@0.34.5

$ npm install next@15.5.28 --package-lock-only --no-audit --no-fund

up to date in 1s
$ npm ls sharp --package-lock-only
sharp-demo@ C:\…\sharp-npm2
`-- next@15.5.28
  `-- sharp@0.34.5

$ npm update sharp --package-lock-only --no-audit --no-fund

up to date in 798ms
$ npm ls sharp --package-lock-only
sharp-demo@ C:\…\sharp-npm2
`-- next@15.5.28
  `-- sharp@0.35.5
  1. The starting point: a lockfile with next 15.5.20 and sharp 0.34.5.
  2. npm install next@15.5.28 --package-lock-only updates only the lockfile, without downloading packages.
  3. next moves to 15.5.28, but sharp stays on 0.34.5: it satisfies ^0.34.3, so npm leaves it alone.
  4. npm update sharp moves it to 0.35.5, the version the advisory asks for.
  5. The last npm ls confirms it.

pnpm 10.2.0 behaved the same: it kept 0.34.5 on pnpm add next@15.5.28 and moved to 0.35.5 on pnpm update sharp. Next.js 16.4.1 already requires ^0.35.5. The rule for November 3: if an advisory names a version of another package, check it with npm ls <package> after upgrading, not just next.

When the lockfile does not follow

This is how npm ci answers when someone edits package.json by hand and does not regenerate the lockfile. Real output, trimmed:

$ npm pkg set dependencies.next=16.4.1 && npm ci --no-audit --no-fund
npm error code EUSAGE
npm error
npm error `npm ci` can only install packages when your package.json and package-lock.json or npm-shrinkwrap.json are in sync. Please update your lock file with `npm install` before continuing.
npm error
npm error Invalid: lock file's next@15.5.28 does not satisfy next@16.4.1
  1. npm pkg set changes the version in package.json without touching the lockfile, like a hand edit.
  2. npm ci exits with code 1 and installs nothing.
  3. The Invalid line says what does not match. That is the error you want in CI: a red build beats a green one on a different version.

pnpm does the same with --frozen-lockfile: in our test it answered ERR_PNPM_OUTDATED_LOCKFILE and installed nothing.

How to roll back

If the patch breaks something in production, the fastest rollback is redeploying the previous build from your platform. Then bring the repo back in line with production with a revert:

$ git revert --no-edit HEAD
[chore/next-security-2026-11 941a2a3] Revert "chore(deps): next 15.5.28"
 Date: Mon Nov 2 22:41:18 2026 -0600
 2 files changed, 42 insertions(+), 42 deletions(-)
$ npm ci --no-audit --no-fund

added 22 packages in 28s
$ npm ls next
npm-demo@1.0.0 C:\…\npm-demo
`-- next@15.5.27
  1. git revert creates a commit that undoes the patch commit: package.json and the lockfile go back to 15.5.27, and history keeps both.
  2. npm ci reinstalls from the reverted lockfile.
  3. npm ls next confirms you are back on 15.5.27.

Reverting a security release leaves you exposed again. Use it to buy time: fix what broke and redeploy the patched version.

Common mistakes

  • Upgrading to latest from 15.x. Today npm install next@latest installs 16.4.4: a major version change, not a patch.
  • Mistaking a bug-fix release for the security release. 16.4.4 on November 2 and 16.3.7 on September 29 both shipped a day before a security release, without its fixes.
  • Editing package.json without regenerating the lockfile. With npm ci, CI fails; with npm install, it quietly resolves another version.
  • Deleting the lockfile to fix a merge conflict. You regenerate the whole dependency tree on the day you only meant to move one package.
  • Trusting next info. It flags a patched 15.x as outdated, because it compares against latest.
  • Checking only next. If the advisory names another package, like sharp 0.35.5 in October, check that too: with an existing lockfile it can stay on the old version.
  • Counting on the host's firewall. It is a stopgap mitigation, not the patch.
  • Assuming the deploy went out. Check the version running in production and, in a monorepo, every copy of next.

Frequently asked questions

Which versions does the November 3 Next.js security release ship?

As of November 2, none have been published. The notice gives no version numbers or CVEs; it says the full advisories, with affected versions and upgrade instructions, come out with the release. We will update this article with the real versions once they appear on the Next.js blog.

Do I need to upgrade if I am still on Next.js 15?

Yes. Next.js 15 is in Maintenance LTS and, per the support policy, gets security releases through January 31, 2027. Every 2026 release shipped a 15.5.x version; use the one the November post gives for your line.

What if my project is on Next.js 14?

Next.js 14 is unsupported, and the October 14 update only shipped 16.4.1 and 15.5.28. The policy says versions outside LTS may be patched in rare circumstances, but it does not promise it. We cover it in why Next 14 has no patch for the October RCEs.

Can I wait a few days to upgrade?

Next.js recommends upgrading once the release is available. Seven medium-severity issues are not seven you can ignore: read each advisory, and if one affects a feature you use, treat it as urgent. If none does, still upgrade in your next cycle so the following jump stays small.

Checklist

  • You wrote down the Next.js version running in production and the deployed commit.
  • The lockfile is committed and CI installs with npm ci or its frozen equivalent.
  • The build and the tests pass today on main.
  • You have a smoke test that covers your flows and the advisory areas you use.
  • You know how to redeploy the previous build and have rehearsed it.
  • On release day you read the post and every advisory before touching anything.
  • You upgrade to your line's version, on a branch, without changing major versions.
  • The lockfile diff only moves next, @next/env and @next/swc-*, plus eslint-config-next if you use it and any package the advisory names.
  • You checked with npm ls the version of every package the advisory names, not just next.
  • After the deploy, you confirm the version in production.

A scheduled security release is the best version of bad news: you know the date a week ahead. If you are still on 14, your problem is a different one: Next 14 has no patch for the October RCEs. To test before you deploy, use the checkout smoke test, and to keep the change clean in your history, the git workflow for AI agents. And remember that upgrading next does not upgrade the runtime: how to update Node in Docker after the October security releases.

Saw this on Instagram? Comment PARCHE on the Reel and I'll send you the guide.

Written by

Luis Morales

Luis Morales

Frontend and Shopify developer, EcomLabs

@luismoralesdev on Instagram

Published November 2, 2026 · updated November 3, 2026

← Blog