This Fall, the PHP Foundation shipped emergency fixes for PHP2Shell, two critical flaws in the language behind roughly 70% of the web. Researchers using AI found the issues months earlier, but attackers found them too. Amazon’s threat team spotted an exploitation attempt four days before the fix went public, and some governments took entire websites offline rather than wait.
For most IT teams, applying the patch went fast. The scramble around it ate the rest of the day: figuring out which systems ran PHP, who had the authority to act, whether anyone had already slipped in, and what planned work would slide while everyone stopped to deal with it.
That scramble’s the real story; a 24-hour response doesn’t start when the advisory lands. It starts with the inventory, the people, and the decisions you put in place months earlier, back when nothing was on fire.
Summary
Fast patch response comes down to a handful of decisions made in advance: a current inventory of what you run, a response team with real authority instead of a single go-to person, and a documented plan that says who can take a site offline and which advisories justify dropping the roadmap. Slingshot’s engineers explain how to triage by both CVE severity and what data sits behind a vulnerable system, and why deployment automation beats a rushed manual fix. They also cover the step most teams skip: keeping the logs and partner contracts that tell you whether anyone got in before the patch did.
Attackers Live in the Gap Between Discovery and Fix
Every critical vulnerability opens a window: the stretch between when people learn a flaw exists and when your systems actually close it. PHP2Shell showed how wide and how crowded that window has become.
The disclosure didn’t go to plan. The vulnerability team had invested months verifying the flaws and preparing fixes, but details surfaced ahead of schedule. “Somehow it was released four days early,” said Doug Compton, Director of AI Engineering at Slingshot. “They noticed hackers had already started doing things with it before the planned announcement. Within hours of the fix going out, attackers had scaled up their scanning and were trying to take control of websites.”
That speed changed the calculus for anyone who couldn’t patch immediately. “A lot of companies took down their sites that day,” said Andrew Meyer, Principal Senior Developer at Slingshot. “They wanted to make sure they couldn’t be exploited during the gap between when it was discovered and when it was patched.”
Pulling a public site offline is a drastic, expensive move. Organizations made it because, at that instant, they had no faster way to close the window. The question for any CIO is whether their team could’ve closed it faster, and what it would’ve taken.
Older Code Didn’t Get Riskier. Finding Its Flaws Got Easier.
The flaws behind PHP2Shell sat in code that dates back more than a decade. Researchers reportedly noticed the underlying bugs years ago and decided they were too complex for a person to chain into a working attack. AI-assisted research erased that barrier, and the same capability works just as well for attackers.
For a CIO running older systems, that should reset the risk conversation. “If it’s publicly accessible software, whether it’s a website or an API, that’s a ticking time bomb,” Doug said. “If it’s internal, you’ve got a little more leeway, but it’s also a false sense of security. All it takes is a hacker getting into your network, and that software is easy to reach.”
PHP2Shell also wasn’t a one-off. “In October alone, there were so many critical security issues found,” Doug said. “PHP, Linux, several very important pieces of software.” Expect more of these warnings, not fewer, as AI keeps digging through foundational code.
Not every emergency fix holds the same significance, either. “It depends on what needs to change,” Doug said. “An infrastructure update is usually a matter of upgrading the software and making sure nothing breaks. A change to your own custom code could need longer testing to verify it doesn’t break other things. You’re trading one risk for another: the security risk versus the risk of breaking your app.”
PHP2Shell fell into the first category, which made it quick to patch for teams that knew where PHP lived. The next one may land in your own code, where speed and safety pull in opposite directions.
Know What You Run Before Anyone Asks
The first hour of a response rests on one question: are we affected? Teams that can answer it quickly spend the day patching. Teams that can’t spend it searching.
“You need an incident response plan, and you need a proper inventory of what your systems look like,” said Steve Anderson, Principal Developer and AWS Architect at Slingshot. “You’ve got to have that in place first, otherwise you’re scrambling. You may not even be impacted; you’d have everybody running fire drills for no reason.”
That second point gets overlooked. Without an inventory, a team can’t rule anything out, so every alert pulls in the whole department. A current list of applications, the languages and frameworks they run on, and which ones face the public turns a panicked morning into a short checklist.
Scanning tools carry part of that load before an advisory ever lands. “It’s important to have tooling in place that can scan for and discover CVEs across your codebase,” Andrew said. “That lets you be more proactive.”
Once a team knows what to fix, the next risk sits in how they ship it. “Deployment automation is also important in these scenarios,” Andrew said. “If you’re in a rush and trying to deploy software manually, you can make mistakes. Having that automation lets you get something out there quickly without it being prone to human error.”
An emergency is the worst possible time to run a deployment process by hand for the first time. Automation built for ordinary releases becomes the safest path out of an extraordinary one.
Build a Response Team, Not a Response Hero
Many organizations quietly rely on one person who knows the stack, watches the feeds, and drops everything when something breaks. That works right up until the day that person’s on a plane.
“It shouldn’t be a person; it should be a team,” Steve said. “And you want people on that team who are empowered to do something about it.”
Empowerment matters as much as headcount. A team that can spot an advisory but needs three approvals to act on it still loses the race. So does a team with the wrong skills: “If you’ve got people who typically work on app dev, this may not be in their tool bag,” Steve said. “You want somebody comfortable in that space working on it.”
Most teams carry a roadmap that leaves no room for surprises, so an emergency patch always comes out of something else. “Your normal work and your deadlines suffer,” Doug said. “If you don’t have staff dedicated to this, they have to drop what they’re doing. That could be a couple of hours or a couple of days, and it affects your deliveries.”
Then comes the uncomfortable part: what happens when the right people are off. Doug didn’t sugarcoat it. “This is one of those emergencies that requires all hands on deck. People should expect they may be called in, but only if it’s a true emergency; don’t abuse it.”
Leaders should set the fair version of that expectation long before the emergency. Teams should know which events justify a call on a day off, who gets the call, and how the company makes it right afterward. And for organizations without that depth in-house, Doug offered a practical alternative: “If you don’t have that level of expertise in your organization, look at partnering with somebody who can help.”
Decide Who Pulls the Plug Before It’s 2 a.m.
During PHP2Shell, the NSA advised organizations to patch immediately or take vulnerable sites offline. That guidance puts a very expensive decision on someone on your team, often in the middle of the night.
Someone has to own that call, and in most organizations, the answer’s already sitting on the org chart. “That would primarily be the DevOps engineer,” Andrew said.
But knowing whose job it is and giving them the authority to act are two different things. “Taking down a website could cost you thousands, if not millions of dollars, depending on the site,” Doug said. “You either need to empower your people and trust that they’ll do the best they can, or the CEO needs to be the one who gets woken up in the middle of the night to make the call.”
Neither option works if people only figure it out in the moment. “This goes back to having an incident response plan,” Steve said. “That should all be policy and documented already. The order of operations shouldn’t be a surprise to anybody.”
The same plan should spell out what counts as an emergency in the first place. Not every advisory deserves a midnight call. “A lot of that is in the CVE itself, the severity of it,” Steve said. “Something like PHP2Shell, where it literally gives remote attackers access to your system, is ‘stop everything, do it now.’ Exploits that require other things to be in place first, like already having network access, tend to get lower severities and a different level of urgency.”
Severity scores only tell half the story. The other half depends on what sits behind the vulnerable system. “Is custom or sensitive data accessible? What could they do once they get there?” Doug said. “That’s a judgment call.”
Steve put it more bluntly. “First, ask yourself if you even care. Maybe it’s just some random box, and you don’t care if they get it. It just depends on what’s there.” A server holding customer records is a different conversation. Teams that sort their systems by blast radius ahead of time make faster, calmer calls when the alert lands.
A Patch Closes the Door. Your Logs Show Who Walked Through It.
Applying the fix stops the next attacker. It tells you nothing about the ones who arrived first. With PHP2Shell, exploitation attempts started days before the fix existed, so ‘we patched’ and ‘we’re safe’ aren’t the same thing.
Answering the second question depends entirely on work done beforehand. “Hopefully you had your house in order before it happened, and you have logs and audit trails running across your network where you can see forensic evidence of an exposure,” Steve said. “If you don’t have any of that, you’re just guessing.”
Doug offered the darkly funny alternative: “If you don’t know you were hacked, you don’t have to report it.” Steve had a name for it: “We call that the ignorance-is-bliss approach.”
The joke lands because plenty of organizations operate exactly that way, whether they mean to or not. Logging feels like overhead on a peaceful Tuesday. On the day after a critical disclosure, it becomes the only thing standing between a confident answer to leadership and a shrug.
That same principle applies to the partners who maintain your systems. “You should have SLAs and a clear definition of who’s responsible for what,” Steve said. “Everybody should know where that line is, and it should already be in your contract.” If an outside team runs your software, find out now who monitors advisories, how quickly they commit to respond, and who checks for signs of a breach afterward.
The Clock Starts Long Before the Alarm
PHP2Shell made the problem shape clear. AI now surfaces old, buried flaws faster than ever, and attackers move into the gap between discovery and fix within minutes. The patch itself is rarely the hard part; everything around it decides whether a team responds in hours or loses days.
Teams that handle these situations well do the unglamorous work early. They know what they run, rely on an enabled team instead of a single hero, and have already decided who can take a site offline and when to drop the roadmap. They keep logs that show whether anyone got in, and their partner contracts spell out who owes what.
No team builds any of that during the emergency. They build it on typical days, when the request for an inventory, a policy, or a logging budget feels like it can wait.
The next advisory’s already on its way. And you’re already deciding whether it costs you an hour or a week.
Backups Need People Too
Written by: Savannah Cherry
Savannah leads marketing and new business at Slingshot. She writes, posts, and creates all things Slingshot, and helps companies navigate working with a tech partner for the first time. While she isn’t developing software, her CIS minor and a tendency to tinker with AI tools to streamline her own work keep her up to speed on the team’s work. She co-organizes and hosts the Louisville AI Exchange, and she can’t rest until all her work is done.
Expert: Doug Compton
Born and raised in Louisville, Doug’s interest in technology started at 11 when he began writing computer games. What began as a hobby turned into his career. With broad interests that range anywhere from snorkeling, science, WWII history and real estate, Doug uses his “down time“ to create new technologies for mobile and web applications.
Expert: Steve Anderson
Steve is one of our AWS certified solutions architects. Whether it’s coding, testing, deployment, support, infrastructure, or server set-up, he’s always thinking about the cloud as he builds. Steve is extremely adaptable, and can pick up the project and run with it. He’s flexible and able to fill in where needed. In his spare time, he enjoys family time, the outdoors and reading.
Expert: Andrew Meyer
Andrew is a developer who started out coding as a young kid: he’d bring home thick programming books from the library and teach himself. That passion for learning and programming would later turn into a career. From game development to SaaS applications, Andrew has worked the gamut of tech, spanning the game, healthcare, marketing, and applicant-tracking industries. Andrew would describe himself as a Big Kid because he is curious about new technologies and loves to explore new ideas.
Frequently Asked Questions
For a critical vulnerability that gives remote attackers access to your systems, like PHP2Shell, the answer is immediately, often within 24 hours or less. Attackers now use AI to turn a published fix into a working exploit within hours, so the gap between disclosure and patching is when most organizations are most exposed. Lower-severity issues that require an attacker to already have network access can usually follow a normal patch schedule.
A strong plan includes a current inventory of every application and the languages and frameworks it runs on, a named response team with the authority to act, and clear rules for which advisories justify dropping planned work. It should also say who can take a system offline, who gets called on a day off, and what partners and vendors are responsible for. Deciding all of this ahead of time is what lets a team respond in hours instead of days.
A team, not a single person. Relying on one expert breaks down the moment that person is unavailable, and response speed depends on people who are both skilled in infrastructure and security work and empowered to act without waiting on approvals. Organizations without that depth in-house should consider partnering with a firm that can provide it.
If you can't patch quickly and the site is publicly accessible, taking it offline can be the safest option, and during PHP2Shell the NSA recommended exactly that. It's also expensive, so the decision should be made in advance by weighing what data sits behind the system and how much downtime costs. Your incident response plan should name who has the authority to make that call.
Only through logs and audit trails that were already running before the incident. Applying a patch stops future attacks but tells you nothing about attackers who got in first, and with PHP2Shell, exploitation attempts started days before the fix existed. Without that forensic evidence, a team can only guess whether its systems were compromised.




