← Back to Blog

The Change Management Lie: Why Engineers Write Fake Tickets on Friday Afternoon

October 29, 2026 · 6 min read
The Change Management Lie: Why Engineers Write Fake Tickets on Friday Afternoon - Deploying hotfixes on Tuesday, then drafting fake Jira tickets on Friday. How SOC 2 change management breaks down and how to automate verifiable proof.

On Tuesday at 2:15 PM, an expired TLS certificate takes down the checkout API. Transactions fail, customer support lines light up, and executive Slack channels fill with red exclamation marks.

A platform engineer diagnoses the issue in three minutes, generates a replacement certificate, updates the secret configuration in Git, pushes directly to production, and restores service.

The fire is out. Revenue flows again.

Then Friday afternoon arrives.

The engineering manager opens a spreadsheet provided by the SOC 2 compliance consultant. The auditor has requested a random sample of twenty production deployments from the past quarter. Each deployment must map to a pre-approved ticket in Jira, complete with business justification, risk assessment, peer review sign-off, and a QA verification timestamp recorded before the code reached the cluster.

The manager finds the Tuesday commit. There is no ticket. The engineer committed the change during a live outage while on a phone bridge with the VP of Engineering.

What happens next is repeated across hundreds of technology companies every week: the engineer opens Jira, creates a ticket titled PROD-4091: Routine configuration maintenance, backdates the description, pastes the GitHub pull request URL, and messages a colleague: Can you click Approve on this ticket real quick? The auditor needs it.

The colleague clicks Approve. The paper trail is restored. The auditor receives a clean PDF export and checks the box for Common Criteria 8.1.

It is the corporate equivalent of buying a train ticket after reaching your final destination just so you can hand it to the conductor.


Why the Process Inverts Under Pressure

SOC 2 Common Criteria 8.1 (CC8.1) and ISO 27001 Control 8.32 state that changes to infrastructure and applications must follow a documented management process: authorization, testing, and approval before release.

The intention is reasonable: prevent rogue developers from deploying untested code or backdoors into live environments.

The failure lies in how organizations implement the requirement. Most compliance frameworks treat the ticketing system as the single source of truth for change authorization. The policy assumes a rigid chronological conveyor belt:

  1. A product manager creates a ticket.
  2. An architecture board reviews the ticket.
  3. An engineer writes code.
  4. QA tests the build in staging.
  5. A manager signs off.
  6. The deployment pipeline runs.

This sequence works during routine sprint cycles. It collapses completely during outages, emergency hotfixes, and rapid continuous delivery.

When production is burning, waiting twenty minutes for an asynchronous Jira approval workflow is irresponsible. Engineers bypass the formal gate to save the business. But because the compliance policy fails to distinguish between routine releases and emergency mitigations, the team must invent a fictional administrative history to satisfy the annual audit.

The result is compliance theatre: tickets that describe decisions already executed, approvals granted without inspection, and audits that evaluate paperwork rather than system integrity.


Replacing Ticket Paperwork with Cryptographic Lineage

The problem is not that engineers bypass ticketing systems. The problem is that compliance frameworks mistake Jira for an operational control.

Jira is a task tracker. GitHub, GitOps controllers, and container registries are system controls.

To eliminate retroactive ticket forgery, organizations replace manual form-filling with automated cryptographic lineage in the deployment pipeline. A compliant deployment must satisfy three programmatic conditions:

  1. Deterministic peer review: Branch protection rules enforce that every merge into the production branch requires signed approval from someone other than the author.
  2. Automated verification gates: CI pipelines run unit tests, security linters, and vulnerability scans before creating a signed release manifest.
  3. Formalized break-glass logging: When an emergency fix bypasses standard staging gates, the system automatically tags the release, alerts on-call leads, and requires an automated post-incident review payload.

Here is a lightweight GitHub Actions workflow step that validates change authorization programmatically before container images receive a production signature:

import os
import sys
import requests
from dataclasses import dataclass

@dataclass
class ChangeEvidence:
    commit_sha: str
    pr_number: int
    author: str
    approver: str
    ci_status: str
    is_emergency: bool

def verify_production_change(repo: str, pr_number: int, github_token: str) -> ChangeEvidence:
    headers = {
        "Authorization": f"Bearer {github_token}",
        "Accept": "application/vnd.github.v3+json"
    }
    
    # 1. Fetch Pull Request details
    pr_url = f"https://api.github.com/repos/{repo}/pulls/{pr_number}"
    pr_data = requests.get(pr_url, headers=headers).json()
    
    author = pr_data["user"]["login"]
    commit_sha = pr_data["merge_commit_sha"]
    labels = [label["name"] for label in pr_data.get("labels", [])]
    is_emergency = "hotfix" in labels or "break-glass" in labels
    
    # 2. Fetch review approvals
    reviews_url = f"https://api.github.com/repos/{repo}/pulls/{pr_number}/reviews"
    reviews = requests.get(reviews_url, headers=headers).json()
    
    approvers = [
        r["user"]["login"] for r in reviews 
        if r["state"] == "APPROVED" and r["user"]["login"] != author
    ]
    
    if not approvers and not is_emergency:
        print(f"Error: PR #{pr_number} lacks independent peer approval.", file=sys.stderr)
        sys.exit(1)
        
    approver = approvers[-1] if approvers else "BREAK_GLASS_SYSTEM"
    
    # 3. Verify CI checks passed on merge commit
    status_url = f"https://api.github.com/repos/{repo}/commits/{commit_sha}/status"
    status_data = requests.get(status_url, headers=headers).json()
    ci_status = status_data.get("state", "unknown")
    
    if ci_status != "success" and not is_emergency:
        print(f"Error: Commit {commit_sha} did not pass CI test suites.", file=sys.stderr)
        sys.exit(1)

    evidence = ChangeEvidence(
        commit_sha=commit_sha,
        pr_number=pr_number,
        author=author,
        approver=approver,
        ci_status=ci_status,
        is_emergency=is_emergency
    )
    return evidence

if __name__ == "__main__":
    repo_name = os.environ["GITHUB_REPOSITORY"]
    pr_num = int(os.environ["PR_NUMBER"])
    token = os.environ["GITHUB_TOKEN"]
    
    record = verify_production_change(repo_name, pr_num, token)
    print(f"Audit Verified: {record.commit_sha[:8]} approved by {record.approver} (Emergency: {record.is_emergency})")

When this evidence is bound directly to the container build through Cosign or Sigstore, the artifact itself carries the proof of review and testing.


What to Show the Auditor Instead

When audit season begins, the team does not hand the auditor a list of retroactively generated Jira links. They provide a queryable audit ledger extracted directly from Git and CI:

  • Every production release corresponds to a Git commit hash.
  • Every commit hash traces to a pull request with an independent reviewer ID and a cryptographic signature.
  • Emergency releases carry a break-glass flag, accompanied by incident timestamps and a link to the post-mortem document.

Auditors accept this model because it removes human fabrication from the sampling pool. A screenshot of a Jira ticket proves that someone typed into a text box. A signed Git commit tied to a pipeline run proves that the control operated inside the running software.

The goal of change management is not to slow down engineering during a crisis. It is to know who deployed what, who reviewed it, and why it was necessary.

Once that lineage is captured by code, Friday afternoon can return to what it was meant for: wrapping up work and going home.


Does your team still write retroactive tickets before compliance reviews, or have you connected your audit logging directly to your GitOps pipelines?

Have a project in mind?

Let's talk about how we can help.

Got a project idea? →