skip to content

How do you read an approved emergency change record as evidence when triaging a 04:00 database bulk export?

level: middleimportance: must knowfreq 62%

answer

  1. join, do not just find
  2. time, scope, identity, approval
  3. created after is a question
  4. shared account names nobody
  5. corroboration, never authorisation

basics

~20 s

A change record proves only that a ticket exists with a stated scope, requester and approver. Join it to the activity on four axes - time, scope, identity and approval path - before it counts as corroboration, and never as authorisation.

solid answer

~50 s

Treat the ticket as a claim to be joined against what you observed, on four axes. **Time**: when was it created and approved relative to the activity? A record created ninety seconds after the export is a new question, not corroboration - some emergency processes legitimately allow retrospective documentation, so check local policy rather than assuming innocence or fabrication. **Scope**: does it name this system, this schema and this operation, or something adjacent you are being invited to stretch? **Identity**: the audit trail names a database account, often a shared break-glass one, so join to the checkout register to name the human, then compare with the requester. **Approval path**: requester and approver being the same person empties the control. A change system is not a security control - anyone holding the DBA's credentials can also raise a ticket.

code

json · 22 lines
json
{
  "db_audit": {
    "event_time": "2026-03-11T04:03:12Z",
    "db_user": "brk_dba_02",
    "action": "SELECT",
    "object": "payments.card_holder",
    "rows_returned": 4180233,
    "client_host": "jump-02.corp"
  },
  "change_record": {
    "id": "CHG0048812", "type": "emergency",
    "created": "2026-03-11T04:04:41Z",
    "requested_by": "a.mensah", "approved_by": "a.mensah",
    "planned_start": "2026-03-11T04:00:00Z",
    "ci": "payments-db-prod-01",
    "summary": "correct reference rows after failed batch"
  },
  "breakglass_register": {
    "account": "brk_dba_02", "checked_out_by": "a.mensah",
    "checkout_time": "2026-03-11T03:58:02Z", "ticket_ref": null
  }
}

go deeper

for a junior

Know that finding a change ticket is not the end of triage. Be ready to say which fields you compare - the times, the system and objects named, the requester - and to state that a ticket is corroboration rather than proof of authorisation.

for a middle

Walk the four joins with mechanics: which timestamps a change system records, how a shared database account is resolved to a human through a checkout register, and why self-approval empties the control. Explain both outcomes, including the one where the ticket makes things worse.

for a senior

Show the escalation judgment. Say at what point the joins turn an alert into a case with a subject, why you stop calling that person once they are the subject, and exactly what you write in the case note so a reviewer can re-derive your reasoning.

for a principal

Be ready to argue where automated change-record correlation may auto-close and where it may only annotate, who samples the auto-closed set, and what you require of the change process itself before your SOC will lean on it as triage input.

## What a change record is, and what it is not A change record is a workflow artefact: someone asserted an intention, someone else approved it, and a system stamped the times. In triage it is the single most useful non-security lookup, because it is the only place where a human wrote down in advance that unusual activity was going to happen. It is also the lookup most often over-read. **A change record is testimony about intent, not an authorisation decision made by a security control.** Nothing in a change system verifies that the statements executed were the statements described, and nothing prevents a person who holds the right credentials from raising a ticket to paper over their own activity - or an intruder holding those credentials from doing the same. So the skill is not *find the ticket*, it is *join the ticket to the observation and report the residue*. ## The four joins ### 1. Time Three timestamps matter and they are not the same: created, approved, and the planned implementation window. Compare all three to the activity time. - Ticket created and approved comfortably before the window, activity inside it: strong corroboration. - Ticket created after the activity: **a new question, not a verdict either way.** Many organisations' emergency change processes explicitly permit retrospective raising - the engineer fixes the outage at 04:00 and documents it at 04:05, because that is what the policy tells them to do. The analyst's job is to know the local policy. If retrospective raising is normal here, the finding is neutral; if it is not, you have a person who chose to create a paper trail immediately after being observed, which raises rather than lowers your suspicion. - Activity outside the stated window even though the window exists: ask why, because the window is the part the approver actually agreed to. ### 2. Scope Read what the ticket says it covers and compare it, field by field, against the record you are holding: the configuration item or hostname, the schema and object, the operation, and the volume. An emergency ticket that says *correct three rows in the payments reference table* does not cover a four-million-row read of a cardholder table. The pressure at 04:00 is to accept a ticket that is *about the same system* as though it were *about this activity*; resisting that is most of the value an analyst adds here. ### 3. Identity The audit trail carries the account that executed the statements. On a production database fleet that is very often a shared break-glass account, which names nobody. The chain you need is: audit record -> account -> break-glass checkout register (or the jump-host session log, or the privileged access management checkout) -> a human -> compare with the ticket's requester. Every hop can fail, and each failure is itself a finding: a checkout with no ticket reference, a checkout by one engineer while a different one raised the change, or an account used with no checkout at all. ### 4. Approval path Who approved it, and could they meaningfully refuse? Self-approval collapses the control to a self-declaration. Approval by a manager who was on leave, or by a group mailbox nobody reads, is the same thing wearing a suit. In an emergency-change process the approval is often a named on-call authoriser; if the record shows an approver who is not in that role, that is worth a sentence in the case. ## Enrichment that makes the alert worse Most people learn enrichment as the thing that de-escalates: you find the ticket and the alert goes away. The mirror case is the one interviewers probe. A ticket created ninety seconds after the export, requested and approved by the same person, referencing a configuration item that is not the database that was read, and with the break-glass checkout carrying no ticket reference, is **four independent facts that all point the same way**. The alert that arrived as one anomalous query is now a case with a named subject and a documented attempt at cover. The correct move is to escalate to an incident lead - and, importantly, to stop doing the obvious thing of ringing that person to ask about it, because at this point they may be the subject rather than the witness. ## What you write down Whatever the outcome, the case note should say which record you looked at, its identifier, the four join results, and the residual uncertainty in one sentence: *change CHG0048812 covers this host and window but was created after the activity and self-approved; the export volume exceeds the stated scope; break-glass checkout at 03:58 by the same engineer, no ticket reference.* That sentence is what a reviewer, an auditor or the next analyst needs, and it is the difference between an alert that was closed and an alert whose reasoning can be re-examined. ## The line to hold in the interview A change record is corroboration, never authorisation. It raises or lowers your confidence in an innocent explanation, and it can do either. If someone answers *there was an approved change, so it was a false positive*, they have handed an adversary a very cheap way to close their own alerts.

  • The company's emergency process allows raising the change after the fact. Does that neutralise a ticket created ninety seconds later?
    It neutralises the timing alone, not the case. Weigh it against the other joins: whether the same person requested and approved it, whether the stated scope matches the volume and objects actually touched, and whether the break-glass checkout references any ticket. Retrospective raising explains a late timestamp; it does not explain self-approval, a scope mismatch, or an export far larger than the work described.
  • The ticket looks clean. What would still make you keep the case open?
    Evidence the ticket cannot address: the rows leaving to a destination outside the change, a session that continued long after the described work, statements against objects the ticket never mentions, or a checkout by someone other than the requester. A clean ticket explains the intent to touch the system; it does not explain everything the session did while it was there.
  • Should the SOC automate the change-record lookup and auto-close matching alerts?
    Automate the lookup and the attachment of the record - that saves real minutes. Auto-closing on a match is far more dangerous, because the match logic is usually host-and-window only, which is exactly the weak join. If you auto-close at all, require the strong conditions - ticket approved before the activity, different requester and approver, scope fields matched - and sample the auto-closed set regularly.

saying these in an interview costs you the question

  • Says an approved change record means the alert is a false positive
  • Matches only on hostname and time window, ignoring scope
  • Treats the ticket requester as the person who ran the statements
  • Calls a retrospectively raised emergency ticket proof of fabrication
  • Ignores that requester and approver are the same person

context