What is patch management? Process, policy and best practices
Patch management is the process of finding, prioritizing, testing, installing and verifying fixes for the software you run (operating systems, applications and firmware) so known security holes and bugs are closed before attackers can use them. NIST's patch-management guide, SP 800-40 Rev. 4, defines enterprise patch management as “the process of identifying, prioritizing, acquiring, installing, and verifying the installation of patches, updates, and upgrades throughout an organization.”
In practice it's a repeating cycle: know what you run, watch for fixes, decide what goes first, test, roll out, confirm each fix took effect, and keep a record. A patch management policy writes down who does each step and how fast.
What is patch management?
A patch is a change from a program's vendor or maintainers that fixes a problem in it: most often a security vulnerability, sometimes a bug or a compatibility issue. On Linux servers, patches arrive as updated packages from your distribution's repositories. Elsewhere they come as vendor updates, firmware releases or new versions. Patch management is everything around applying them: knowing which systems need which fixes, deciding the order, installing them without breaking anything, and confirming they actually took effect.
NIST's guide covers all three kinds of change, “patches, updates, and upgrades,” and treats patching as preventive maintenance: just as servicing a vehicle fleet avoids costly breakdowns, patching keeps the technology an organization depends on working. It's a cycle, not a project, because fixes never stop arriving.
Why patch management matters
Exploiting a software flaw is now the most common way breaches start: 31% of them in Verizon's 2026 Data Breach Investigations Report, ahead of stolen credentials. Some of the most damaging incidents, Equifax and WannaCry among them, used a flaw that already had a fix. Patch management is how you shorten the time between a fix existing and your systems running it, and NIST notes that installing a patch, update or upgrade is the only response that removes a vulnerability completely without giving up functionality. The breaches and attacker timelines are in our guide to why patching matters.
The patch management process, step by step
The patch management process is a repeating cycle: know what you run, learn about new fixes, decide what goes first, test, roll out, confirm each fix took effect, and keep a record. NIST describes the same life cycle in three stages: know when new vulnerabilities affect your assets, plan the response, and carry it out (prepare, implement, verify, and keep monitoring). As practical steps:
- Inventory what you run. List every server and the software on it, down to packages and libraries, because you can't patch what you don't know about. NIST says inventories need constant, automated updates, and that refreshing them with a monthly or quarterly scan is a model that “should no longer be used.”
- Watch for new fixes and vulnerabilities. Follow your vendors' security notices (on Linux, your distribution's advisories, such as Ubuntu Security Notices, Debian's security tracker and the Red Hat-family errata), plus the National Vulnerability Database and CISA's Known Exploited Vulnerabilities (KEV) catalog.
- Assess and prioritize. Rank each fix by real risk: how severe the flaw is, whether it's being exploited (KEV is the clearest public signal), whether the system is reachable from the internet, and how important the system is. This is also where you decide between routine patching and an emergency.
- Test. Try the patch where a failure is cheap. NIST recommends phased rollouts in which a small set of “canary” systems gets the patch first; if they're fine, the rollout widens.
- Approve and schedule. Decide who signs off, especially for changes that restart services or reboot servers, and when they run, coordinated with change management and the people who own the systems.
- Deploy. Install the patch, then restart the affected services or reboot where the fix needs it. Resolve anything that goes wrong before you move on.
- Verify. Check that the fix is in effect, not just installed. In NIST's words, for patching, verification means “confirming that the patch is installed and has taken effect.” A new kernel on disk doesn't protect a server that hasn't rebooted into it.
- Record and keep monitoring. Keep a record of what changed, when, who approved it and how it was checked, and make sure the fix stays in place. Those records are what you show an auditor or a customer.
Patch management vs vulnerability management
Vulnerability management is the wider job of finding security weaknesses and deciding what to do about each one; patch management is its most common answer. NIST lists four ways to respond to a software vulnerability, and patching is only one of them:
- Mitigate: patch or upgrade the software, disable the vulnerable feature, or add controls such as a firewall rule or network isolation.
- Avoid: remove the attack surface by uninstalling the software or decommissioning the system.
- Transfer: share the consequences, for example through cyber insurance or a software-as-a-service provider that patches for you.
- Accept: live with the risk, relying on existing controls or because the impact is low.
Patching is the preferred response because it's the only one that removes the flaw without losing functionality. The others matter when there's no patch yet, when a patch is broken, or when a system can't be patched at all.
| Vulnerability management | Patch management | |
|---|---|---|
| Question it answers | What weaknesses do we have, and what should we do about each one? | Which fixes need applying where, and are they in effect? |
| Covers | Every known weakness in your systems, whether or not a patch exists | The fixes vendors ship: patches, updates and upgrades, for security flaws and ordinary bugs |
| Main output | A prioritized list of risks and a response for each | Patched, verified systems and a record of each change |
| When there's no patch | Chooses another response: mitigate, avoid, transfer or accept | Applies the fix once it ships, while the interim mitigation holds |
What a patch management policy should include
A patch management policy is the written rulebook for the process: which systems it covers, who approves what, how quickly each kind of fix must be applied, and how you prove it was done. A useful one covers:
- Scope. Which systems and software it applies to, and where the inventory lives.
- Roles and approvals. Who applies patches, who approves risky changes, and who can grant an exception.
- Deadlines by risk. How fast critical, high and routine fixes must be applied, with tighter deadlines for flaws that are being exploited and for systems that face the internet. Many teams start from the deadlines their compliance frameworks set (see the table below).
- Scenarios. NIST suggests planning for four: routine patching, emergency patching, emergency mitigation (when there's no patch yet, or the patch is flawed) and unpatchable assets. It groups systems with similar needs into “maintenance groups” and gives each group a maintenance plan per scenario, with timeframes for each action.
- Testing and rollback. Where patches are tried first, how a rollout widens, and how a bad patch is backed out.
- Maintenance windows and reboots. When services may be restarted and servers rebooted, and how long a pending reboot may wait.
- Exceptions. How a system gets an exception, who signs it off, and when it's looked at again. NIST says every exception should be tracked and reviewed regularly.
- Verification and records. How a fix is confirmed, and what's kept as evidence.
- Metrics. What you'll measure, such as the share of systems patched by the deadline and the mean and median time to patch, broken down by how important the system and the vulnerability are. NIST warns that simply counting vulnerabilities and the percentage patched isn't actionable.
What common frameworks ask for
| Framework | What it asks for | Deadline |
|---|---|---|
| PCI DSS v4.0.1 | Install security patches and updates for critical vulnerabilities | Within 30 days, for critical vulnerabilities |
| CIS Controls v8, Safeguards 7.3 and 7.4 | Automated patch management for operating systems and applications | Monthly or more often |
| CIS Controls v8, Safeguards 7.1 and 7.2 | A documented vulnerability management process and a risk-based remediation process | Process reviewed annually; remediation reviewed monthly or more often |
| ISO/IEC 27001:2022, control A.8.8 | Management of technical vulnerabilities: identify, evaluate and address them | No fixed deadline |
| SOC 2, criterion CC7.1 | Vulnerabilities dealt with in good time | No fixed deadline |
| CISA BOD 26-04 (US federal agencies) | Remediate each vulnerability on a timeline set by four risk factors: public exposure, KEV status, exploit automation and technical impact | Varies with risk; one designation requires action within three days plus a forensic triage of the system |
BOD 26-04 replaced BOD 22-01 in June 2026 and binds only federal agencies, but its four risk factors are a useful model for setting anyone's deadlines. The rows above are summaries: check the current text of any standard you're audited against.
Patch management best practices
Patch management best practices come down to four habits: patch routinely, prioritize by real risk, roll out in stages, and verify what's actually running. The inventory and the records are what make those habits possible.
- Keep the inventory current, automatically. Every later step depends on knowing what runs where.
- Prioritize by exploitation and exposure, not severity scores alone. A medium-severity flaw that's on CISA's KEV list and sits on an internet-facing server can matter more than a critical one on an isolated machine. NIST notes that organizations other than federal agencies may choose to use the KEV catalog to help prioritize their patching.
- Patch routinely so emergencies stay small. NIST points out that routine patching is often postponed because it lacks urgency, and that delaying it makes emergency patching harder, because new patches can depend on earlier ones you haven't installed.
- Automate the routine, and keep a person on risky changes. The CIS Controls ask for automated operating-system and application patching at least monthly; on Linux that's tools such as unattended-upgrades or dnf-automatic. Kernel updates, reboots and major upgrades deserve a person's approval and a planned window. If you're comparing tools, see our ranking of patch management software.
- Roll out in phases. Canary systems first, then the rest, so a bad patch hits a few machines rather than all of them.
- Verify the fix took effect. Check the running kernel and the restarted services, and check per CVE rather than by version number (more on that below).
- Plan for what you can't patch. End-of-life systems and machines that can't go down need isolation or other mitigations, and a date to be replaced. Our Linux end-of-life dates guide lists when each release stops getting fixes.
- Measure, and keep records. Track patched-by-deadline and time to patch per system and vulnerability importance, and keep a record of each change and how it was checked.
What's different on Linux servers
On Linux servers, three details trip up otherwise sound patch management: backported fixes, kernels that need a reboot, and services that keep running old code. Automatic updates help with the routine work but don't cover any of the three.
- Backported fixes. Ubuntu and Debian fix security flaws in the version they shipped instead of moving to a new upstream release, so the version number barely changes. A scanner that only compares version strings can report a fixed package as still vulnerable. Check each CVE against your distribution's own security data instead; our comparison of Linux vulnerability scanners shows which tools do.
- Kernel updates need a reboot. A new kernel is installed on disk but doesn't run until the server reboots, so a server can look updated and still be exposed. On Ubuntu and Debian, unattended-upgrades marks a pending kernel reboot in
/var/run/reboot-required; on AlmaLinux and Rocky Linux, DNF's needs-restarting plugin reports it. Canonical Livepatch can fix high and critical kernel flaws on covered Ubuntu kernels without a reboot, but a real kernel upgrade and reboot is still needed later. See how to check which kernel is running. - Services keep old libraries until they restart. Upgrading a shared library such as OpenSSL doesn't change programs that are already running with the old copy loaded. On Ubuntu 24.04, needrestart restarts affected services after library upgrades; elsewhere you may need to restart them yourself.
- Automatic updates aren't the whole job. Ubuntu Server turns unattended-upgrades on by default and installs security updates once a day, but by default it doesn't reboot, and it doesn't tell you whether each fix is actually in effect. Our unattended-upgrades guide covers what it does and doesn't do.
Where HostCrust fits
For Linux servers, HostCrust handles the checking, approval and record-keeping parts of this cycle. Patch Proof checks every installed package and the running kernel against your distribution's own security data, per CVE, so backported fixes count as fixed. A fix then goes through a guarded change (request, approval, run, verify and receipt), and each receipt can be checked offline with hc-verify. See what HostCrust does, or how applying a patch works.
How we checked this: This is a background guide, not a command walkthrough, so it has no commands of its own; the Linux guides it links to walk through the commands, each run on a real server. On Nov 18, 2026 we checked the definitions, requirements and deadlines against NIST SP 800-40 Rev. 4, CISA Binding Operational Directive 26-04, the CIS Controls v8, the PCI Security Standards Council and DQS's summary of ISO 27001. The Linux details, the breach figures and the SOC 2 criterion rest on sources our other guides had already checked, also listed below. Anything we didn't run ourselves comes from the official documentation listed under Sources.
Check which CVEs are really open on your server
HostCrust Patch Proof compares every installed package with your distribution's own security data. It counts fixes your distro backported and checks the kernel that is actually running, not just the one on disk. Read-only, no root, free.
FAQ
What is a patch?
A patch is a fix released by a program's vendor or maintainers, most often for a security vulnerability and sometimes for a bug. On Linux servers, patches usually arrive as updated packages from your distribution's repositories.
What are the steps of patch management?
Inventory what you run, watch for new fixes, assess and prioritize them, test, approve and schedule, deploy, verify that each fix took effect, then record the change and keep monitoring. It's a cycle that repeats as new fixes arrive.
How often should you patch servers?
Routinely, at least monthly: the CIS Controls ask for automated operating-system and application patching monthly or more often. Critical flaws that are being exploited on internet-facing systems need much faster action, hours to a few days rather than weeks. PCI DSS sets 30 days for critical vulnerabilities.
What's the difference between patch management and vulnerability management?
Vulnerability management finds security weaknesses and decides how to respond to each one. Patch management applies and verifies the fixes vendors release. Patching is the usual response, but when there's no patch, vulnerability management turns to another, such as disabling a feature or isolating the system.
Should patch management be automated?
The routine part, yes: the CIS Controls ask for automated patching, and doing it by hand doesn't scale. Keep a person's approval for changes that can break things, such as kernel updates, reboots and major upgrades, and verify the result either way, because automation can install a fix that never takes effect.
What should a patch management policy include?
Its scope, roles and approvals, deadlines by risk, plans for routine and emergency patching and for systems you can't patch, testing and rollback, maintenance windows, an exception process, how fixes are verified and recorded, and the metrics you'll track.
What if there's no patch for a vulnerability?
Mitigate until one arrives: disable the vulnerable feature, block it with a firewall rule, or isolate the system. If it will never be patched, for example because it's end-of-life, plan to remove or replace it. Either way, track it so the fix is applied when it ships.
Sources
- NIST SP 800-40 Rev. 4: Guide to Enterprise Patch Management Planning: Preventive Maintenance for Technology (April 2022)
- NIST SP 800-40 Rev. 4, full text (PDF): risk responses (2.1), life cycle (2.2), inventories (3.1), scenarios (3.3), maintenance groups and plans (3.4, 3.5), metrics (3.6)
- CISA BOD 26-04: Prioritizing Security Updates Based on Risk (June 10, 2026; revokes BOD 19-02 and BOD 22-01)
- CISA Known Exploited Vulnerabilities (KEV) Catalog
- CIS Controls v8, Control 7: Continuous Vulnerability Management, Safeguards 7.1 to 7.4 (assessment specification)
- PCI Security Standards Council: Just Published: PCI DSS v4.0.1 (patches within 30 days applies to critical vulnerabilities)
- DQS: ISO 27001:2022 controls A.8.8 and A.8.9, management of technical vulnerabilities
- AICPA: 2017 Trust Services Criteria, revised points of focus 2020 (CC7.1; copy hosted by Arpio)
- Verizon: 2026 Data Breach Investigations Report, news release (May 19, 2026): software flaws (31%) are now the top entry point
- U.S. GAO-18-559: Actions Taken by Equifax and Federal Agencies in Response to the 2017 Breach
- CISA alert TA17-132A: Indicators Associated With WannaCry Ransomware (apply MS17-010)
- Red Hat Enterprise Linux life cycle and errata policy
- Ubuntu Security Team FAQ: security and updates pockets, backported fixes
- Debian Security FAQ: backported fixes and the security tracker
- unattended-upgrades upstream: the kernel hook that writes /var/run/reboot-required
- DNF needs-restarting plugin (-r, --reboothint)
- Ubuntu 24.04 LTS release notes: needrestart restarts services after library upgrades
- Canonical Livepatch documentation
- unattended-upgrades upstream README (defaults, including Automatic-Reboot)
- HostCrust Patch Proof v1.0.0 README: classes, kernel handling, known data gaps