I've spent a lot of time keeping work moving across hundreds of locations. One thing I learned pretty quickly is that a job can say "complete" without answering the questions that matter.
Did we fix the right problem? Did the fix actually work? And if something went wrong before we got there, would we even know?
I keep coming back to that when I look at what happened with PHP last week.
Things moved fast
On October 21, the PHP team released fixes for two serious security flaws known as PHP2Shell. Under certain conditions, those flaws could let someone run code on an affected website's server. That's a big deal for businesses using the software. [1]
But the story didn't start on October 21.
Amazon reported an attempted exploit in its monitoring network on October 17, four days before the public announcement. That's evidence of an attempt, not proof that a customer's website was broken into. Still, it changes the timeline. [2]
Fastly reported roughly 250,000 requests associated with PHP2Shell from around 3,200 IP addresses between October 21 and midday October 22. Some traffic described itself as defensive scanning. A request isn't a successful attack, and an IP address isn't necessarily one person. But think about that volume in barely more than a day. [3]
By October 26, the two original flaws had been added to CISA's list of vulnerabilities known to be exploited. The picture changed again as new evidence came in. [4]
This is what sticks out to me: a business might be operating on a weekly update schedule while automated activity is happening almost immediately.
"We patched it" is a start
Putting out a fix is not the same as installing it. Installing it is not always the same as confirming it's running on every affected system.
And even if the update worked, you still have a separate question: What happened before we got it installed?
I'm not saying every company needs some giant new security platform. The basics are hard enough:
Which websites actually had the issue? Did they receive the fix? Has someone checked that it worked? Do we need to look back at suspicious activity? Who is responsible for anything still open?
If the answer to one of those questions is "we don't know yet," that's useful information. At least it's an honest starting point. Marking everything green because a task was checked off is not.
This is bigger than PHP
It's the same problem I see when work moves between people, teams and software.
One person finds an issue. Somebody else is responsible for fixing it. Another person needs to know whether the outcome is real. If those people aren't working from the same information, things fall through the cracks.
Those different roles can also make for good partnerships. Not everyone needs to do everything. Someone might be great at finding the work, someone else at delivering it, and another at checking the result. But the responsibilities need to be clear, especially when the work involves customer systems.
That's the kind of system I want to build: one that doesn't rely on somebody remembering to follow up or trusting a status label without evidence.
When technology moves this fast, I don't think "we should be good now" is good enough.
The question isn't just whether the patch exists. It's whether you can show what changed, what worked, and what you still don't know.
Sources
- PHP project, October 21, 2026 security release: https://www.php.net/archive/2026.php
- Amazon Threat Intelligence, PHP2Shell exploitation attempt observed before public disclosure: https://aws.amazon.com/it/blogs/security/amazon-threat-intelligence-identifies-php2shell-exploitation-prior-to-public-disclosure-in-madpot/
- Fastly Security Research, PHP2Shell traffic observations through October 22, 2026: https://quic.fastly.com/blog/how-fastly-detected-and-built-a-coordinated-response-to-php2shell
- Canadian Centre for Cyber Security, October 27 Update 2 reporting the October 26 CISA KEV additions: https://www.cyber.gc.ca/en/alerts-advisories/al26-026-critical-vulnerabilities-impacting-php-cve-2026-109618-cve-2026-109619