Andrew Mercer
on this page

Exception Management

An exception is a time-boxed, approved decision not to meet a control yet, with a named owner, a reason, compensating controls, and a plan to resolve it. The process exists so that unfixable or not-yet-fixable risk is visible and decided by the right person — not silently tolerated by whoever happened to be on the ticket.

A healthy exception register is small, current, and shrinking. An unhealthy one is a list of things everyone has agreed to forget.


Contents

  1. Vocabulary
  2. When an exception is (and isn't) appropriate
  3. The exception record
  4. Lifecycle
  5. Approval matrix
  6. Compensating controls
  7. The register as code
  8. Tying scanner suppressions to the register
  9. Azure Policy exemptions
  10. Review cadence and driving to resolution
  11. Reporting
  12. Anti-patterns
  13. Templates

Vocabulary

Use these terms consistently; mixing them is how risk gets lost.

Term Meaning Expires?
False positive The finding is wrong — the asset isn't vulnerable. Not an exception. Close with evidence. n/a
Not applicable Control doesn't apply (e.g. asset decommissioned, feature absent). Not an exception. n/a
Deferral / remediation extension Fix is planned but will miss the SLA; new due date agreed. Yes — short (≤ 90 days)
Risk exception Control can't be met for a period; compensating controls reduce the risk; a resolution plan exists. Yes — typically 30–365 days
Risk acceptance Business formally accepts residual risk with no plan to fix (e.g. legacy system being retired). Yes — still re-reviewed at least annually
Compensating control An alternative control that addresses the intent of the original requirement to a comparable degree. Lives as long as the exception
Mitigation Anything that reduces likelihood or impact; may or may not be strong enough to count as compensating. —

When an exception is (and isn't) appropriate

Appropriate:

  • No vendor fix exists yet; mitigations are in place.
  • The fix requires an application upgrade that's scheduled but can't land within SLA.
  • A hardening setting breaks a supported business application; vendor fix is on their roadmap.
  • An EOL system is being decommissioned within a defined window; ESU or isolation covers the gap.
  • An appliance or vendor-managed system you can't patch yourself.

Not appropriate:

  • "We're busy." That's a deferral at most, and it should be escalated, not approved by default.
  • Avoiding a reboot indefinitely.
  • A finding nobody has triaged — triage first.
  • A known false positive — close it as FP with evidence instead.
  • Permanent. Nothing is permanent; long-lived acceptances still get re-reviewed.

The exception record

Required fields — reject requests missing any of them:

Field Description
id Stable identifier, e.g. EXC-2026-0042
title One line, specific
type deferral | exception | acceptance
scope Exactly which assets, findings, controls (resource IDs, CVEs, policy definition IDs, CIS rule IDs)
requirement The control or policy not being met (e.g. "Remediate P2 within 14 days", "CIS 2.3.9.2 SMB signing")
reason Why it can't be met now — specific and verifiable
risk Likelihood × impact in your risk model, with reasoning
compensating_controls List, each with how it's verified
resolution_plan What ends this exception, with milestones
requester Person
risk_owner Business owner who accepts the residual risk (not the engineer)
technical_owner Who executes the resolution plan
approver(s) Per approval matrix
created, approved Dates
expires Hard date. Required.
review_frequency e.g. 30 / 90 days
status See lifecycle
linked_findings Finding IDs / tickets
linked_suppressions Scanner rule IDs, Azure Policy exemption IDs, .trivyignore entries

Lifecycle

Draft → Submitted → Under Review → Approved → Active → (Review) → Active … → Resolved
                         │                       │                     │
                         └→ Rejected             ├→ Expired ───────────┤
                                                 └→ Revoked            └→ Renewed (new approval, new expiry)
Status Meaning Suppressions in scanners?
Draft / Submitted / Under Review Pending decision No — finding stays visible and its SLA keeps running
Approved / Active In force Yes, scoped and with matching expiry
Expired Past expires without renewal Removed automatically — finding reappears with SLA breached
Revoked Compensating control failed or risk changed (e.g. CVE added to KEV) Removed
Resolved Underlying issue fixed and verified Removed
Rejected Not approved None — remediate within SLA

Renewal is a new decision, not a date edit. It requires fresh justification, evidence that the compensating controls still work, and the same (or higher) approval level. Cap renewals — e.g. a P2 exception may be renewed at most twice before escalation to the executive risk committee.

Automatic revocation triggers:

  • CVE is added to CISA KEV, or EPSS jumps above your P1/P2 threshold.
  • Asset exposure changes (internal → internet-facing).
  • A compensating control check fails.
  • A fix becomes available for a "no fix" exception (vendor releases patch) — convert to remediation with a short SLA.

Approval matrix

Approval level scales with residual risk and duration:

Residual risk ≤ 30 days ≤ 90 days ≤ 180 days > 180 days
Low (P4) Team lead Team lead Engineering manager Director
Medium (P3) Engineering manager Engineering manager Director + Security Director + CISO delegate
High (P2) Director + Security Director + CISO delegate CISO CISO + business exec
Critical (P1 / KEV) CISO CISO + business exec Not permitted without risk committee Not permitted

Rules:

  • The requester can't approve their own exception.
  • Security reviews the compensating controls; the business risk owner accepts the risk. Both are needed above Low.
  • Regulatory controls (PCI, SOX, HIPAA scope) may require your compliance function's sign-off regardless of level, and some requirements can't be excepted at all — only met via documented compensating controls the assessor accepts.

Compensating controls

A compensating control must address the same threat the original control addresses, to a comparable degree, and be verifiable. PCI DSS's long-standing definition is a useful standard even outside PCI: it must meet the intent and rigor of the original requirement, provide a similar level of defence, be "above and beyond" other requirements, and be commensurate with the additional risk.

Examples that genuinely compensate

Unmet control Threat Compensating control Verification
Unpatched RCE in internal web service, no fix yet Remote exploitation NSG/firewall restricts inbound to two known app subnets; WAF virtual-patch rule for the exploit path; EDR in block mode NSG effective rules export; WAF rule hit logs; EDR policy report — checked weekly
Windows Server 2016 after EOL (pending migration) Unpatched future vulns ESU enrolled via Arc; isolated VLAN/NSG; no internet egress; admin only via Bastion/PAW ESU license status; NSG rules; firewall logs
SMB signing disabled for legacy scanner appliance Relay/MITM Dedicated file share server for scan-to-folder; share accessible only from appliance IP; account restricted to that share Share ACL & firewall rule review monthly
Container image with unfixed base-OS CVE in an unused library Exploitation of library Library unreachable (no network listener, not loaded); readOnlyRootFilesystem, non-root, NetworkPolicy deny-all ingress except ingress controller Reachability analysis attached; pod security admission audit

Things that aren't compensating controls

  • "The server is internal." (Internal networks are where lateral movement happens.)
  • "We have antivirus."
  • "Nobody knows it's there."
  • "It's behind the firewall" — without specifying which rule restricts which path.
  • A control that already exists and is required anyway (e.g. "we have MFA" when MFA is mandated for everything) — it doesn't add anything for this specific gap.

Each compensating control needs an automated or scheduled check. If it isn't checked, assume it's gone.


The register as code

A spreadsheet works for twenty exceptions and fails at two hundred. A Git repository of YAML files gives you review (merge requests), history (who approved what, when), and automation (expiry checks in CI) for free — and it fits naturally alongside infrastructure code.

Layout

risk-exceptions/
├── README.md
├── schema/exception.schema.json
├── exceptions/
│   ├── EXC-2026-0041.yaml
│   ├── EXC-2026-0042.yaml
│   └── ...
├── archive/            # resolved / expired / rejected, kept for audit
└── scripts/
    ├── validate.py
    └── report.py

Record

# exceptions/EXC-2026-0042.yaml
id: EXC-2026-0042
title: "OpenSSL CVE-2026-XXXXX on legacy billing appliance — no vendor patch"
type: exception
status: active
scope:
  assets:
    - "/subscriptions/1111.../resourceGroups/rg-billing/providers/Microsoft.HybridCompute/machines/billing-appl-01"
  findings: ["VM-2026-004512"]
  cves: ["CVE-2026-XXXXX"]
requirement: "VULN-SLA-P2: remediate within 14 days"
reason: >
  Appliance firmware is vendor-controlled. Vendor advisory VA-2026-118 commits
  to a fixed firmware in release 7.4, ETA 2027-01-15.
risk:
  likelihood: medium
  impact: high
  rating: high
  notes: "EPSS 0.03 at time of request; not in KEV."
compensating_controls:
  - id: CC-1
    description: "NSG nsg-billing denies all inbound except TCP/443 from snet-billing-app"
    verification: "scripts/checks/nsg_rules.sh billing-appl-01 — runs daily in CI"
  - id: CC-2
    description: "Appliance has no outbound internet; egress via Azure Firewall deny-all"
    verification: "Firewall policy rule collection 'billing-egress' review"
resolution_plan:
  - milestone: "Vendor firmware 7.4 released"
    due: 2027-01-15
  - milestone: "Firmware applied in maintenance window"
    due: 2027-01-31
requester: "[email protected]"
risk_owner: "[email protected]"
technical_owner: "[email protected]"
approvals:
  - name: "[email protected]"
    date: 2026-11-08
    role: security
  - name: "[email protected]"
    date: 2026-11-09
    role: risk_owner
created: 2026-11-06
approved: 2026-11-09
expires: 2027-02-15
review_frequency_days: 30
last_reviewed: 2026-11-09
renewals: 0
revoke_if:
  kev_listed: true
  epss_above: 0.10
linked_suppressions:
  - system: defender-for-cloud
    ref: "disable-rule:CVE-2026-XXXXX:billing-appl-01"
  - system: azure-policy
    ref: "/subscriptions/1111.../providers/Microsoft.Authorization/policyExemptions/exc-2026-0042"

CI validation

#!/usr/bin/env python3
"""validate.py — fail CI on malformed, expired, or overdue-review exceptions."""
import sys, datetime, pathlib, yaml

TODAY = datetime.date.today()
REQUIRED = ["id", "title", "type", "status", "scope", "requirement", "reason",
            "risk", "compensating_controls", "resolution_plan", "risk_owner",
            "technical_owner", "approvals", "expires", "review_frequency_days",
            "last_reviewed"]
MAX_DAYS = {"deferral": 90, "exception": 365, "acceptance": 365}

errors, warnings = [], []
for f in sorted(pathlib.Path("exceptions").glob("*.yaml")):
    e = yaml.safe_load(f.read_text())
    missing = [k for k in REQUIRED if k not in e]
    if missing:
        errors.append(f"{f.name}: missing {missing}")
        continue
    if e["id"] != f.stem:
        errors.append(f"{f.name}: id does not match filename")
    expires = e["expires"]
    approved = e.get("approved")
    if approved and (expires - approved).days > MAX_DAYS[e["type"]]:
        errors.append(f"{e['id']}: duration exceeds {MAX_DAYS[e['type']]} days for {e['type']}")
    if e["status"] == "active" and expires < TODAY:
        errors.append(f"{e['id']}: EXPIRED {expires} — renew, resolve, or move to archive/")
    elif e["status"] == "active" and (expires - TODAY).days <= 14:
        warnings.append(f"{e['id']}: expires in {(expires - TODAY).days} days")
    next_review = e["last_reviewed"] + datetime.timedelta(days=e["review_frequency_days"])
    if e["status"] == "active" and next_review < TODAY:
        errors.append(f"{e['id']}: review overdue since {next_review}")
    if e.get("requester") in [a["name"] for a in e["approvals"]]:
        errors.append(f"{e['id']}: requester cannot approve own exception")

for w in warnings: print("WARN ", w)
for x in errors:   print("ERROR", x)
sys.exit(1 if errors else 0)

Run it on every merge request and on a daily schedule — the scheduled run is what catches expiry without anyone touching the repo.

# .gitlab-ci.yml (excerpt)
validate-exceptions:
  image: python:3.13-slim
  script:
    - pip install --quiet pyyaml
    - python scripts/validate.py
  rules:
    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
    - if: $CI_PIPELINE_SOURCE == "schedule"

Protect the exceptions/ path with CODEOWNERS so security must approve merges, and require the risk owner's approval as a second approver.


Tying scanner suppressions to the register

Every suppression in a tool must point back to a register entry, and must expire no later than it.

Tool Suppression mechanism Expiry support
Defender for Cloud (vulnerability findings) Disable specific findings rules on vulnerability recommendations (by CVE / severity / image / resource) Rules don't expire by themselves — automate removal from the register
Defender for Cloud (recommendations) Azure Policy exemptions (below) Yes (expiresOn)
Qualys Ignore vulnerability / VMDR exceptions with comments Set and track the end date in the exception
Tenable Recast / Accept rules with comments Yes (expiration date on accept rules)
Trivy .trivyignore.yaml with statement and expired_at Yes
Grype .grype.yaml ignore rules with reason No — enforce via review
Dependabot / Renovate Dismiss alert with reason / ignoreDeps Limited — track in register

Convention: put the exception ID in every suppression's comment/reason field (EXC-2026-0042). Then a nightly job can list all suppressions across tools and flag any whose ID isn't an active register entry — orphaned suppressions are the most common way exceptions outlive their approval.

Trivy example:

# .trivyignore.yaml
vulnerabilities:
  - id: CVE-2026-XXXXX
    paths:
      - "usr/lib/libexample.so.3"
    statement: "EXC-2026-0057 — library not loaded; base image fix pending upstream"
    expired_at: 2026-12-31

Azure Policy exemptions

Azure Policy has first-class exemptions with categories and expiry, which makes it a good model even if most of your findings come from elsewhere.

Category Use when
Waiver Accepting non-compliance (risk exception/acceptance)
Mitigated The intent is met another way (compensating control)

Terraform

resource "azurerm_resource_policy_exemption" "exc_2026_0042" {
  name                 = "exc-2026-0042"
  resource_id          = data.azurerm_arc_machine.billing_appl_01.id
  policy_assignment_id = data.azurerm_management_group_policy_assignment.server_baseline.id

  # Exempt only specific policies inside an initiative
  policy_definition_reference_ids = ["linuxSshdHardening"]

  exemption_category = "Mitigated"
  expires_on         = "2027-02-15T00:00:00Z"
  display_name       = "EXC-2026-0042 billing appliance SSH config"
  description        = "See risk-exceptions/exceptions/EXC-2026-0042.yaml"

  metadata = jsonencode({
    exceptionId = "EXC-2026-0042"
    riskOwner   = "[email protected]"
    approvedBy  = ["[email protected]"]
  })
}

Better still: generate exemption resources from the register YAML (a small script or Terraform for_each over decoded YAML files), so the register is the single source of truth and Terraform removes exemptions when entries are archived.

locals {
  exceptions = {
    for f in fileset("${path.module}/../risk-exceptions/exceptions", "*.yaml") :
    trimsuffix(f, ".yaml") => yamldecode(file("${path.module}/../risk-exceptions/exceptions/${f}"))
  }
  policy_exemptions = {
    for id, e in local.exceptions : id => e
    if e.status == "active" && try(e.azure_policy, null) != null
  }
}

resource "azurerm_resource_policy_exemption" "from_register" {
  for_each             = local.policy_exemptions
  name                 = lower(each.key)
  resource_id          = each.value.azure_policy.resource_id
  policy_assignment_id = each.value.azure_policy.assignment_id
  exemption_category   = each.value.type == "acceptance" ? "Waiver" : "Mitigated"
  expires_on           = "${each.value.expires}T00:00:00Z"
  display_name         = "${each.key} ${each.value.title}"
}

Listing exemptions

policyresources
| where type == "microsoft.authorization/policyexemptions"
| extend expires = todatetime(properties.expiresOn),
         category = tostring(properties.exemptionCategory),
         excId = tostring(properties.metadata.exceptionId)
| project name, category, expires, excId, scope = tostring(split(id, "/providers/Microsoft.Authorization")[0])
| order by expires asc

Exemptions with no expiresOn or no exceptionId in metadata are orphans — alert on them.


Review cadence and driving to resolution

Exceptions don't resolve themselves. Someone has to keep pushing them.

Cadence

Exception risk Review every Review asks
Critical/High 30 days Are compensating controls still verified? Did threat intel change (KEV, EPSS, exploit public)? Is the resolution plan on track?
Medium 60–90 days Same, lighter evidence
Low 90–180 days Still needed?

A weekly 30-minute exception stand-up

Agenda, in this order:

  1. Expiring in ≤ 14 days — renew (with fresh approval), resolve, or let expire (and accept the SLA breach visibility).
  2. Revocation triggers fired — KEV additions, exposure changes, failed control checks.
  3. Resolution milestones due — is the vendor patch out? Is the migration on schedule?
  4. New requests — triage completeness before routing to approvers.

Driving with the right owners

  • Name a person, not a team, as technical owner. Teams don't answer emails; people do.
  • Put resolution milestones into the owning team's backlog as real work items with due dates, linked from the exception.
  • When a milestone slips, the exception's risk owner gets the escalation — they accepted the risk, they decide whether to fund the fix.
  • Make exception counts visible in the same team-level dashboards as vulnerability SLAs. Teams with many long-lived exceptions should be discussed at the same forum as teams with SLA breaches.

Expiry automation

  • 30, 14, 7 and 1 day before expiry: notify technical and risk owners.
  • On expiry: CI flips status, Terraform removes exemption, nightly job removes tool suppressions, findings reappear with SLA breached — and that's intended. The visible breach is the forcing function.

Reporting

Monthly report to leadership (one page):

Section Content
Totals Active exceptions by risk level; trend vs last 3 months
Age Median age; count > 180 days; count renewed ≥ 2 times
Expired/breached Exceptions that expired without resolution
Top risks The five highest residual-risk exceptions, with risk owner and resolution date
Revocations Exceptions revoked this month and why
Resolved Exceptions closed this month (good news matters)

Exception data should be queryable alongside vulnerability data — same asset IDs, same owner fields — so a team's risk picture includes both "open findings" and "findings we've agreed to live with for now."


Anti-patterns

  • No expiry. Every record expires.
  • Engineer as risk owner. The person accepting business risk must have authority over the business process.
  • Suppress first, approve later. Suppressions only after approval.
  • Compensating controls by assertion. If it isn't verified on a schedule, it isn't a control.
  • Silent renewal. Renewals require new approval and evidence.
  • Blanket scope. "All servers in subscription X" is not a scope; list assets or define a precise filter.
  • Spreadsheet in someone's OneDrive. Use a system with history and access control.
  • Exceptions for false positives. Close FPs with evidence; don't clutter the register.

Templates

Exception request (for ticketing systems that aren't Git)

Title:
Type: deferral | exception | acceptance
Scope (assets, findings/CVEs, controls):
Requirement not met:
Why it can't be met now (specific, verifiable):
Risk assessment (likelihood, impact, threat intel e.g. KEV/EPSS):
Compensating controls (each with how it's verified and how often):
Resolution plan (milestones with dates):
Requested duration / expiry date:
Requester:
Technical owner (person):
Risk owner (person with business authority):
Linked tickets / findings:

Review record

Exception ID:
Review date:
Reviewer(s):
Compensating controls verified? (evidence links):
Threat changes since last review (KEV/EPSS/public exploit):
Resolution plan status:
Decision: continue | revoke | resolve | escalate
Next review date:

References

  • PCI DSS v4.0.1, Appendix B (Compensating Controls) and Appendix C (Compensating Controls Worksheet)
  • NIST SP 800-37 Rev. 2 (Risk Management Framework) and SP 800-30 Rev. 1 (Risk Assessments)
  • Azure Policy exemption structure — Microsoft Learn
  • Trivy ignore file documentation — trivy.dev