4 min read
Keeping up with constant patching
Security releases now land faster than most teams can absorb them. Here's why patching feels relentless at the moment, and the habits I think make it manageable for frontend teams.
If it feels like you’re patching something every week at the moment, you’re not imagining it.
Take Next.js. After September’s scheduled security release, it shipped an out-of-band fix on 14 October for two critical remote code execution bugs, one in use cache functions and one in the Image Optimization API. Three weeks later, on 3 November, another release fixed seven more issues, most of them in Cache Components. And that’s one framework. Your package.json probably has a few hundred more packages behind it.
Zoom out and the numbers are startling. Last Friday, VulnCheck’s count of CVEs published in 2026 passed 100,000, more than double the whole of 2025. Only around 1.4% of those have been seen exploited, but the ones that are get exploited faster: VulnCheck puts the median time to exploitation at 80 days in the first half of this year, down from 120 in 2025.
It’s a challenge I’ve seen first-hand at Dojo, and I don’t think the answer is “try harder”. Teams that keep up have usually made patching boring: small, routine and cheap. Here’s what I think gets you there.
Why it feels relentless right now
A few things are stacking up at once.
More disclosure. More researchers, more bug bounties and more automated tooling mean more bugs are being found and reported. That’s a good thing, but it lands on your backlog.
Frameworks do more on the server. Modern React frameworks now run server functions, caches and image pipelines for you. The November Next.js advisories are almost all about caching: data from one user or tenant leaking into another’s cached response. When the framework owns more of the stack, more of the security surface is in code you didn’t write.
The supply chain is a target. Self-spreading npm worms like Shai-Hulud showed how quickly a compromised maintainer account can turn into hundreds of poisoned packages. That creates an awkward tension: you want to update fast for security fixes, but updating to every new version the moment it’s published is exactly how worms spread.
What I’d do about it
1. Make patching a routine, not an incident
If patching only happens when someone shouts, every patch feels like an emergency. Give it a slot instead: a weekly or fortnightly dependency window with a named owner, rotating through the team. Small, frequent upgrades are far easier to review and roll back than one big catch-up every quarter.
2. Triage by real risk, not the headline score
Not every advisory needs a same-day fix. The questions I’d ask are:
- Do we use the affected feature? Most of the November Next.js issues only apply if you use Cache Components,
use cacheor Edge routes. If you don’t, it can go in the next routine window. - Is it being exploited? CISA’s Known Exploited Vulnerabilities catalogue is a much stronger signal than a CVSS number.
- Is it reachable from the internet without logging in? Unauthenticated remote code execution, like October’s, jumps the queue. Always.
Severity labels aren’t as objective as they look, either. The November Next.js post rates one advisory High, while the GitHub advisory for the same issue rates it Moderate. Read what the bug actually does.
3. Split security fixes from version churn
Most update noise isn’t security at all, it’s routine version bumps. Treat the two differently:
- Version updates: group them (one PR for all your linting tools, one for testing libraries and so on) and add a cooldown, so you only pick up releases that have been public for a few days.
- Security updates: let those through straight away.
The cooldown is doing two jobs. It cuts PR noise, and it gives the community time to spot a malicious release before it reaches you.
The tooling has caught up with this. Dependabot now waits three days by default before opening a version update PR, while security updates still open immediately. pnpm has a minimumReleaseAge setting that defaults to one day, and npm added a similar minimum release age option this year. Andrew Nesbitt’s case for cooldowns is worth a read: of ten supply chain attacks it cites, eight had a window of opportunity under a week.
4. Stay on a supported version
This is the one that bites hardest. Next.js only ships security fixes for its Active and Maintenance LTS lines, which right now means 16.4.x and 15.5.x. If you’re a couple of majors behind, there may be no patch for you at all, only a migration. Upgrade debt is security debt, so budget for major upgrades the way you’d budget for any other maintenance.
5. Make shipping a patch cheap
A patch PR should be able to go from opened to production the same day. That needs a decent test suite you trust, preview deployments, and a few automated smoke tests on the journeys that matter most: sign in, checkout, whatever pays the bills. If merging a one-line version bump needs a manual regression pass, patches will queue up.
6. Check the patch actually landed
Updating package.json isn’t the same as being patched. Check the version that’s actually deployed (npm ls next in the built image, not on your laptop), and remember that some fixes need more than a redeploy. Netlify’s notes on the November release are a good example: one of the cookie issues also needed their Next.js adapter updating, and cached content from old deploys and preview branches had to be purged separately.
7. Have fewer dependencies
The cheapest patch is the one you never have to make. Every so often, look at what you’re pulling in. Small utility packages that the platform now does natively, or two libraries doing the same job, are easy wins.
The short version
You can’t stop the flow of advisories, but you can make each one cheaper to deal with. Patch on a schedule, triage by real risk, cool down routine updates but fast-track security ones, stay on supported versions, and make shipping a patch a non-event.
I’d love to hear how other teams handle this. What’s worked for you?