On 20th October, the PHP team announced that two critical security vulnerabilities had been discovered, with emergency updates scheduled for the following day.
Not ideal.
Especially when you're responsible for maintaining multiple websites, all running on different servers, with different configurations and various versions of PHP.
Suddenly, that perfectly reasonable to-do list you've been working through doesn't seem quite so important anymore.
And just when things were starting to settle down, November decided to join in.
But we'll get to that.
So, what actually happened?
On 21st October 2026, PHP released emergency security updates to address two critical vulnerabilities, CVE-2026-109618 and CVE-2026-109619.
The vulnerabilities could potentially allow attackers to execute malicious code remotely or access sensitive information in certain circumstances.
In simpler terms, someone could potentially compromise a vulnerable server without needing to log in.
Lovely.
Both vulnerabilities received a CVSS severity score of 9.2 out of 10, which is about as close to PHP waving a giant red flag as you can get.
The PHP team was pretty clear about the solution, too. Updating to a patched version was the recommended way to address the vulnerabilities.
The fixes were released for PHP 8.2, 8.3, 8.4 and 8.5.
So, naturally, developers everywhere started checking their servers.
And that's where the fun really began.
Surely you just update PHP?
You'd think so, wouldn't you?
Log into your hosting control panel, select the latest patched version, click save and carry on with your day.
Sometimes, that's exactly what happens.
Other times, you discover that the version you need isn't available on the server yet.
Or the server has received a security update, but your project's dependencies require a newer PHP version.
Or Composer decides that today is a good day to remind you about every dependency conflict you've ever encountered.
Brilliant.
The frustrating thing is that updating PHP isn't necessarily the difficult part.
It's everything surrounding it.
A website might be running Craft CMS, a collection of plugins and various third-party packages. Those packages have their own requirements, which need to be compatible with the PHP version you're trying to use.
A dependency requiring PHP 8.4.1 or higher isn't particularly helpful when your hosting environment is still running PHP 8.3.
And when you're managing several websites, you can't necessarily apply the same solution to all of them.
What works perfectly on one server might cause problems on another.
Not all hosting is created equal
This is probably one of the more frustrating parts of maintaining websites.
You can have two websites running essentially the same technology, yet updating them can be two completely different experiences.
One hosting provider might make security patches available almost immediately.
Another might take longer to roll them out.
Some give you complete control over PHP versions, extensions and server configurations.
Others give you a dropdown and hope for the best.
And when you're trying to respond to a critical security vulnerability, waiting for a hosting provider to make an update available isn't exactly reassuring.
To be fair, hosting providers need to test their updates too. Nobody wants a rushed change breaking hundreds of websites.
And some providers apply security patches to existing PHP versions without changing the version number you'd normally expect to see.
But it does highlight how much we rely on infrastructure that's often outside our control.
You can write secure code, keep your CMS updated and follow all the recommended practices.
But if the server underneath it can't be patched, there's only so much you can do yourself.
And then there's Composer
I do like Composer.
Most of the time.
It makes managing PHP dependencies significantly easier, and I wouldn't particularly fancy maintaining modern PHP projects without it.
But there's something quite special about running an update when you're already stressed about a security vulnerability, only to be greeted by a wall of dependency conflicts.
You need a newer version of PHP.
A package requires a different version.
Another package won't update because something else is locked.
And suddenly you're reading dependency trees when all you wanted to do was make sure your website was secure.
Of course, Composer is doing exactly what it's supposed to do.
It's preventing you from installing incompatible packages.
Very sensible.
Still annoying.
Updating something shouldn't mean breaking something else
There's also the small matter of making sure everything continues to work after an update.
Because a successful PHP update doesn't automatically mean the website is fine.
A CMS might behave differently. A plugin might rely on functionality that's changed or been deprecated. An extension might be missing from the new environment.
And occasionally, something that worked perfectly yesterday decides it no longer wants to cooperate.
This is why testing matters.
It's tempting to treat a PHP security update as a quick server change, especially when there's pressure to get everything patched.
But I'd rather spend a little longer checking that the website actually works than discover later that a critical feature has stopped functioning.
That doesn't mean delaying an urgent security fix indefinitely while you test every possible scenario.
It means having a sensible process for applying updates, checking compatibility and dealing with problems quickly.
Ideally without having to question your entire career halfway through.
Oh, we're doing this again?
Just when things were starting to settle down, PHP had another surprise for us.
On 18th November, the PHP security team announced that another round of security updates would be arriving the following day.
And yes, more critical vulnerabilities were involved.
Of course they were.
On 19th November, new security releases arrived for the supported PHP versions, including PHP 8.3.37, 8.4.28 and 8.5.13.
So, once again, we're back to checking PHP versions, reviewing hosting environments and making sure everything is patched.
To be fair, these updates are part of PHP's regular four-week release cycle, rather than another unexpected emergency release.
And the PHP team explained that the vulnerabilities classified as critical required non-default configurations or uncommon setups.
That's reassuring, at least.
But after October, seeing another critical PHP security announcement wasn't exactly the highlight of my Thursday.
At this point, I'm starting to think PHP has a personal problem with my to-do list.
Website maintenance is more than clicking update
I think this whole situation highlights something that often gets overlooked.
A website isn't something you build, launch and then forget about.
Even if nobody changes a single line of code, the technology running it continues to evolve.
- PHP releases new versions.
- CMS platforms release updates.
- Plugins change their requirements.
- Security vulnerabilities are discovered.
- And hosting environments need maintaining.
Most of the time, nobody notices any of this happening.
Which is exactly how it should be.
But behind the scenes, somebody needs to keep track of it all.
And when something like October's PHP vulnerabilities happens, all that ongoing maintenance suddenly becomes a lot more important.
It's also why keeping websites reasonably up to date matters. The longer a project goes without maintenance, the harder it can become to make urgent changes when they're needed.
Nobody wants to discover that their website is several major versions behind when a critical security patch lands.
Can we have a quiet month now?
I don't think there's anything particularly unusual about software having security vulnerabilities.
They happen. They're discovered, reported and fixed. That's part of maintaining software used by millions of websites.
And I'd much rather know about a vulnerability and have a patch available than have it go unnoticed.
The PHP team deserves credit for communicating the risks and releasing the fixes.
But the last few weeks have been a good reminder that even seemingly straightforward updates can involve an awful lot of moving parts.
Between PHP versions, hosting configurations, dependency requirements and making sure websites continue to function, there's rarely a universal fix that works everywhere.
Sometimes everything updates without a problem.
Sometimes you lose an afternoon to Composer.
And sometimes you find yourself staring at a server configuration wondering why something that should work simply doesn't.
Anyway, PHP.
Same time next month, I suppose?