Audit Trails That Outlast Your Supplier Contracts

Somewhere in your procurement folder is a contract that expires next quarter. Fine. But what happens to the audit trail that came with it—the emails, inspection reports, corrective action plans, shipping logs? If the trail lives only in the supplier's portal or one procurement officer's inbox, you're about to lose it. And losing it isn't just messy. It's a compliance gap. It's a hole in your due diligence history. It's the reason a customer's audit suddenly turns hostile.

Here's the thing: contracts end, but the legal and ethical obligations don't. You may need to prove what you knew and when—long after the signature page is moot. This guide walks through what it takes to build an audit trail that survives supplier churn, data migrations, and even the loss of your most organized employee.

Where Audit Trails Go to Die in Real Supply Chains

Record Lifecycles End Before the Work Does

The supplier contract has a termination date. The audit trail—the evidence of where materials came from, who touched them, and what certifications were valid—doesn't. Yet most companies treat them as one unit. When the contract ends, the records get archived, the access gets revoked, and the trail quietly suffocates in a folder no one opens. That's the default behavior. It's also wrong.

Think about what actually happens at contract end. The procurement team sends a closeout notice. Finance processes the final invoice. Legal files the agreement. And the operational data—the shipment logs, the inspection reports, the carbon footprint calculations—gets dumped into a shared drive or an old ERP module. The people who understood those records move on to other projects. The supplier's new contact person doesn't respond to emails. Within six months, the trail exists but nobody can interpret it. Within two years, nobody even knows it exists.

I have seen this pattern repeat across industries. A food distributor lost its entire traceability chain for a raw ingredient when a five-year supplier relationship ended. The contract had a standard data-retention clause—three years post-termination. The clause was never enforced. The supplier's server was wiped during their own migration. Nobody checked until a customer asked for proof of origin on a batch produced four months before the contract lapsed. That's a long silence followed by a very loud problem.

What Kills a Trail: Mergers, Shutdowns, and the Key Person Walkout

Three scenarios repeat themselves with depressing regularity. First, a merger. Your supplier gets acquired. The new parent company consolidates systems—and your historical audit data was on the legacy platform that gets decommissioned. You weren't notified. You didn't ask. The trail evaporates without a single alarm.

Second, a supplier shutdown. Plant closes, employees scatter, the cloud subscription lapses. Your audit trail was stored on their infrastructure because it felt easier. Well, easier until the lights go out. You retain the right to access records, but the records are locked behind a bankruptcy proceeding that takes eighteen months to resolve. The trail isn't gone—it's just inaccessible. That's a distinction the regulators don't care about.

Third, the key person departure. This one is subtle. The supplier's quality manager—the one who maintained the batch records, the calibration logs, the audit responses—leaves for another job. Their replacement inherits a mess they don't understand. Your request for historical documentation gets met with confused silence. The relationship is still active, but the trail's continuity is broken. Nobody owns it anymore. That's the most common failure mode, and it doesn't appear on any risk register.

Offboarding Is the Afterthought That Compounds

What usually breaks first is the offboarding checklist. It exists—almost every company has one. But it focuses on access removal and final invoice settlement. Audit trail migration gets a footnote at best. The assumption is that the data will be fine because it was fine yesterday. That assumption holds until the day it doesn't, and that day always lands during a customer complaint or a regulatory spot-check.

The root cause is ownership. During the contract's active life, the supplier relationship manager feels responsible for the data. After termination, responsibility becomes a gray zone. Procurement says it's legal's problem. Legal says it's IT's problem. IT says the data isn't on their systems. The trail dies in the handoff. Nobody deliberately killed it—everyone just assumed someone else was holding the leash.

An audit trail isn't a deliverable you hand over at contract end. It's an asset you steward until the last question about that supply chain is answered—years later, usually by someone you've never met.

— Former supply chain compliance lead, consumer goods

Fix this before you need to fix it. That means defining, in the contract itself, what happens to the audit trail at termination—not just retention duration, but format, access method, and a named contact who will respond to data requests for a defined period. It means pulling a copy of all trail-critical records into your own environment before the contract closes, not after. And it means assigning a human being who remains responsible for fielding questions about that supplier's data—even if the questions stop coming for two years.

Most teams skip this. They treat the trail as a byproduct of the relationship rather than a business asset with a lifespan of its own. The cost of that oversight only appears later—when a customer asks, when an auditor probes, when a lawsuit surfaces. By then, the trail is cold. Records are lost, formats are unreadable, and the one person who knew the context has left. The trail didn't die of natural causes. It died of administrative neglect.

The Building Blocks People Actually Mix Up

Evidence, metadata, index—not the same thing

Most teams lump these together and call it “the trail.” That’s how trails die. Evidence is the thing itself—a signed delivery note, a photo of pallets, a customs stamp. Metadata is what wraps it: who captured it, when, on which device, from what GPS coordinate. An index is the map you use to find either later. Wrong order here and you’ll store gigabytes of photos with zero context. Or worse, you’ll keep perfect timestamps for files that vanished.

The catch is that each layer fails differently. Evidence gets corrupted or lost. Metadata gets stripped by accident—a re-uploaded PDF, a phone that resets its clock. Indexes rot when someone renames a folder structure. I have seen a supplier’s entire audit history become unsearchable because one intern migrated files to a cloud drive and changed the naming scheme. All data, no access. That’s not a trail; it’s a pile.

Legal hold vs. business retention—why the distinction matters

Legal hold means you freeze everything because a dispute, investigation, or lawsuit might touch those records. Business retention is your operational policy—how long you keep what, and why. They collide constantly. A standard retention schedule might purge supplier audit records after three years. But if a contract dispute surfaces in year two, the legal hold kicks in and overrides that schedule. The reverse also bites: teams keep everything “just in case” because they never learned when a legal hold actually applies.

That sounds fine until your storage bill explodes or your legal counsel asks why you still have records you should have deleted under data protection rules. Keeping everything is not diligence—it’s risk in another costume. One manufacturing client of mine kept supplier audits for a decade because nobody wanted to decide what mattered. When a privacy audit hit, they had to defensively justify possession of records that should have been destroyed years prior. The fix was brutal: a weekend of deleting files, with legal watching over their shoulders.

You don’t need a perfect record of everything. You need a defensible reason for what you keep, and a clean path to what you must retrieve.

— supply chain compliance manager, mid-sized electronics firm

Why “just keep everything” is not a strategy

It sounds pragmatic. Storage is cheap. Who loses by keeping all records forever? You do—in findability, in legal exposure, in operational speed. A trail that holds every scan, email, and photo becomes a swamp. When a real audit arrives, your team spends days hunting for the correct delivery date instead of minutes. Promiscuous retention also hides gaps: if you never decide what’s essential, you won’t notice when essential items disappear.

The honest move is triage. Decide what evidence is non-negotiable (proof of origin, certifications, corrective action records). Separate that from nice-to-have context. Set explicit destruction dates for the latter. Then index only the essential tier—metadata and search paths that survive staff changes. The rest can exist in cold storage, unsearchable and uninsurable. You’ll lose a few historical details. In exchange, you gain a trail that actually works when a buyer, regulator, or journalist asks to see it.

Field note: restaurant plans crack at handoff.

Patterns That Keep Trails Alive After the Contract Signs Off

Designing a neutral, portable record format

The fastest way to kill a trail is to lock it inside a proprietary schema your supplier’s system spits out. You know the drill—a CSV with columns that shift meaning every quarter, or a JSON blob that only a former contractor's script can parse. That's not an audit trail; that's a hostage. What survives contract termination is the record that any competent analyst can read five years later without a decoder ring. Think plain text with explicit timestamps, immutable event IDs, and a field-by-field dictionary stored alongside the data itself.

We fixed this once by agreeing on a minimal common format with a mid-tier fabric mill. No shared software, no API handshake—just a spec: event_id|timestamp|actor|action|object|checksum. They shipped a flat file weekly; we ingested it into our own archive. The supplier switched ERP systems mid-contract, and the format held. That's the test, honestly. Can your trail survive a vendor's upgrade, a merger, or a bankruptcy without requiring a forensic archaeologist?

The catch is that portability costs you richness. You can't embed every nuance of a complex production step in a pipe-delimited line. The trade-off is clear: capture the immutable essentials in a neutral format, then keep richer context in a separate, clearly versioned annex. Don't mix them—or you'll lose both when the tooling changes.

Embedding audit triggers into buying systems

A trail that depends on someone remembering to log events is not a trail—it's a diary with gaps. The pattern that works is friction-free capture: the audit event fires automatically when a purchase order changes status, when a shipment clears customs, when a quality inspection flags a deviation. You don't ask for the data; the system emits it as a side effect of normal workflow.

The pitfall? Over-triggering. I've seen teams wire logging into every click, generating terabytes of noise that bury the few signals that matter. Start with ten event types, not fifty. Ask yourself what would prove a claim of ethical sourcing in a dispute—that's your trigger list. Add more only when someone demonstrates a real gap in the audit narrative.

Assigning a records steward who outlives the contract

Someone must own the archive after the supplier's relationship ends. Not the procurement manager who negotiated the deal—they'll move on. Not the compliance officer who only cares about active suppliers. A dedicated records steward, with a defined retention budget and explicit authority to chase down missing records, is the difference between a dusty vault and a living archive.

Most teams skip this role entirely and hope the legal department remembers. That's wishful thinking. Your steward should have a calendar reminder that fires quarterly, checking that the data is still readable, the checksums still verify, and the storage format hasn't gone obsolete.

The contract expires, but the evidence doesn't. Someone has to guard the guardrails.

— field note from a compliance lead at a mid-sized textile importer

The tough question is who pays for this steward after the supplier cash flow stops. Budget from the start for a post-contract retention period—three to five years is common for potential legal or customer scrutiny. The cost is small next to defending a lawsuit without a traceable record. Not glamorous work. But it's the difference between a story you can tell and a story you must invent.

Why Teams Fall Back into Chaos—and the Anti-Patterns Behind It

The Over-Engineering Trap

Teams don't usually decide to wreck their audit trail. They decide to build a perfect one. That's the trap. Somewhere between procurement specs and a compliance kickoff, someone drafts a schema with 47 mandatory fields, nested approvals, and a blockchain flourish that impresses nobody except the vendor who gets paid by the hour.

I have watched this happen twice now. The first time, the system captured everything—every keystroke, every timestamp, every digital signature—until operators simply stopped using it. The second time, the trail was so rigid that legitimate exceptions couldn't flow through, so people created shadow spreadsheets to track what actually mattered. Both trails failed, but not because the data was wrong. They failed because the cost of recording truth exceeded the cost of forgetting it.

The fix isn't less rigor. It's less friction. You can keep three fields and still prove provenance if those three fields are the ones your suppliers already touch daily.

Key-Person Dependency: When One Inbox Holds Everything

Here's a scene I see constantly: the compliance manager who built the audit process leaves for another role. Her replacement inherits a shared drive with 11,000 files, no index, and a password protected spreadsheet that nobody else knows exists. That's not an audit trail—it's an archaeological dig waiting to happen.

Audit trails die when knowledge concentrates in a single person, a single laptop, or a single email thread. The moment a supplier asks for documentation at 4:55 PM on a Friday, the only answer is "I'll check with Maria," and Maria is out until Tuesday. That hurts more than the delay—it erodes trust with every partner who depend on your record-keeping.

The correction is boring but effective: rotate the custody of your trail. Have two people reconcile monthly. Export to an open format quarterly. Keep the history somewhere a stranger could reconstruct without asking questions. Wrong order, though—if you try to rotate before you simplify, you'll just multiply the confusion.

An audit trail that only one person can unlock is not a record. It's a hostage situation.

— observation from a former garment factory quality lead, now running her own compliance consultancy

The 'Set It and Forget It' Fallacy

You automate the capture, configure the alerts, and then… nothing. For six months, the system hums along, producing beautiful PDFs nobody reads. Then a supplier rebrands, a factory changes legal name, or a raw material batch gets rerouted halfway across the ocean. The trail still contains all the old references, but they no longer match reality.

That's drift—slow, silent, and expensive. It creeps in through unupdated vendor IDs, stale contact lists, and certificates that expired while the dashboard showed green. The trail isn't lying, exactly. It's just describing a company that no longer exists.

Most teams skip this part: the periodic "does this still make sense?" review. Not a full audit, just a half-day where someone traces five recent shipments backward and checks whether the digital breadcrumbs still line up. That hygiene task feels less urgent than onboarding the next client, but the payoff is asymmetrical—one caught mismatch can save you from a recall, a fine, or a headline.

The hard truth is that trails degrade in proportion to how boring they're. When no one looks at them for months, they calcify. The costs of letting go include not just the embarrassment of a failed inspection but the quiet erosion of supplier confidence. If your partners notice that your records lag their reality, they'll stop treating the audit loop as a source of truth—and start treating it as theater.

Keeping the Trail Fresh: Maintenance, Drift, and the Real Costs of Letting Go

Regular Audits of Your Audit Trail

The trail you built last quarter isn't the trail you have today. Suppliers rotate staff, systems get upgraded, and someone inevitably "cleans up" an old shared drive. I've watched teams discover that their crown-jewel traceability data was quietly sitting in a decommissioned folder structure—present, intact, but effectively gone. You need to audit the trail itself, not just the supply chain it tracks.

That means scheduling a quarterly review where you sample records end-to-end. Pick five SKUs, trace them from raw material to dispatch, and check whether every step actually links. Most teams skip this. The catch is that broken links compound silently—one missing transformation in month three makes month six's batch reconciliation a nightmare. You're not looking for perfection here. You're looking for the seams before they blow out.

What usually breaks first is the handoff between systems. Your ERP logs a purchase order. Your supplier's portal logs a shipment. Somewhere between them, a line item gets dropped or a date format shifts. That's your drift—and it's cheaper to catch in a half-day sample than during an audit your customer's compliance team requested.

Cost of Storage vs. Cost of Loss

Storing everything forever feels responsible. It isn't. But neither is trimming aggressively to save a few dollars on cloud fees. The real question isn't "what can we afford to keep" — it's "what would losing this cost us if a dispute surfaces two years from now?"

Storage math is seductive. A terabyte of logs costs pennies a month, so teams hoard raw telemetry that has zero evidentiary value. The opposite failure is costlier: organizations that delete supplier records after contract termination, assuming the relationship is over. Wrong order. Your customer contract might require you to prove provenance for goods sold three years ago—and the supplier that made those goods is now bankrupt or hostile. The moment you lose access to their records, your own completeness claim fractures.

The trade-off is brutal but simple. Keep immutable copies of all records tied to committed purchases, product batches, and quality certificates. Let transient telemetry go. That means defining retention tiers that distinguish "evidence" from "noise," and ensuring that evidence trails survive supplier churn—not because you expect litigation, but because you can't predict what tomorrow's regulatory question will demand.

How to Prevent Metadata from Decaying

Metadata rots faster than the data it describes. A file name that makes sense to the person who created it—Q3_final_v2_checked.xlsx—is meaningless to anyone else, including future-you. I've seen audit trails where the substance is solid but the metadata is so degraded that nothing can be reliably joined across systems.

The fix isn't glamorous: establish naming conventions, timestamp standards, and unit-of-measure rules before you need them. Then enforce them at the point of capture, not during quarterly reconciliation. That's the part most people miss—metadata maintenance happens at the edge, inside supplier portals and ERP entry screens, not in a governance document someone approved and forgot.

Bad metadata is like a warehouse where every box is labeled "stuff." The inventory count looks fine until you need one specific item.

— operations lead, mid-sized apparel manufacturer

That's the real cost of letting go. It's not a storage fee; it's the day you can't reconstruct what happened, and a customer's compliance officer asks a question nobody can answer. You can't retroactively fix decayed metadata. But you can decide today which records matter enough to protect, which can age out, and which need a human check every quarter. That decision—not the software you buy—is the maintenance that keeps your trail alive. Do the sampling, set the retention tiers, and fix one naming convention this week. Start there.

When Fighting for a Perfect Trail Is the Wrong Move

Low-risk suppliers and the luxury of letting go

Not every supplier deserves a forensic-grade audit trail. That sounds heretical coming from someone who has watched teams burn weekends reconstructing purchase orders from PDFs—but hear me out. A low-risk supplier—say, a regional vendor providing generic office supplies, or a subcontractor handling a single non-critical batch—may only need basic proof of delivery, a dated invoice, and a signature. That's it. You don't need blockchain timestamps or tamper-evident seals for a transaction that, worst case, costs you a few hundred dollars and a replacement order.

The catch is knowing which suppliers are actually low-risk. I have seen companies slap "minimal records" policies on every vendor under a certain spend threshold, only to discover that a "small" supplier was the sole source for a regulated component. Wrong call. The rule should be based on exposure—regulatory, reputational, operational—not just invoice size. If a supplier's failure would trigger a recall, a fine, or a headline, they aren't low-risk, no matter how small the contract.

So what does a lighter trail look like in practice?

• Purchase order, delivery note, and invoice kept in a shared folder—no formal chain-of-custody software.
• One named person responsible for spot-checking documents quarterly.
• Retention period tied to the shorter of: tax requirements or two years past contract end.

That's not negligence. It's proportionality.

Overfitting to a future audit that may never come

Teams build elaborate trails because they fear an audit they can't quite picture. The regulator will swoop in, demand three years of provenance data, and you'll be caught flat-footed. That fear is real, but it rarely matches the actual risk profile. Most audits—customer-led or regulatory—start with a narrow question: "Show us how you verified this specific shipment's origin" or "Where did this batch of raw material come from?" They don't ask for everything, everywhere, all at once.

Building a perfect trail for every transaction is like insuring your house against a meteorite strike while your pipes leak. The probability-weighted cost doesn't justify the expense. Worse, over-engineering creates its own failure mode: when the trail is too complex, people stop maintaining it, and you end up with a beautiful system full of gaps.

One useful question: what's the most expensive mistake a missing record could cause? If the answer is "a fine we'd probably negotiate down" or "a customer we'd likely retain with a sincere apology," then a lighter touch isn't weakness—it's judgment. That said, there's a difference between pragmatic simplification and lazy abandonment, and you need a rule to tell them apart. Write down what you're *not* tracking, and why. Review it annually. If the rationale still holds, you're making a choice, not an oversight.

Balancing cost against risk in your retention strategy

Storage is cheap; attention isn't. The real cost of a heavyweight audit trail isn't the server space—it's the hours your team spends entering data, checking timestamps, and chasing missing signatures. Those hours compound across dozens of suppliers, and suddenly you've spent two full-time equivalents on a system that hasn't caught a single problem in three years.

I've seen the flip side too: a company that cut retention to save money, then lost a dispute with a customer because they couldn't prove a delivery date. That hurt. But the answer wasn't "track everything forever." It was "track delivery dates for all suppliers, and skip the rest of the metadata."

So set a cost ceiling. If maintaining the trail costs more than 1–2% of the contract value, step back. Ask whether the extra records would change any decision you're likely to make. If not, trim. Not every supplier is a potential scandal.

Honestly — most restaurant posts skip this.

Perfection is a lovely goal until it eats your entire budget. Better to have ninety percent coverage that you actually maintain than a hundred percent that you fake.

— supply chain manager, mid-sized manufacturer, reflecting on their audit trail redesign

Your next step is concrete: pick your three lowest-risk suppliers, list what you currently track for each, and delete half of it. Set a reminder to revisit in six months. If nothing breaks, you've found your new baseline.

Open Questions and Straight Answers on Audit Trails

How long should you actually keep records?

Longer than your contract, shorter than forever, and there's a sweet spot you can defend in court. Most compliance teams default to seven years because that's what accounting does—but audit trails aren't ledgers. If a product has a 15-year warranty, your supplier records need to outlive that timeline. If regulators in your sector require 10 years, seven won't cut it. The practical answer: keep records for the longest of three durations—contractual obligations, regulatory minimums, or product lifecycle plus liability exposure. Then add two years. That buffer has saved me more than once when a dispute arrived late.

But here's the catch—storage isn't your problem. Data formats are. I have seen perfectly preserved PDFs from 2012 that were unreadable in 2023 because the supplier used proprietary software. Keep raw XML, CSV exports, or original database dumps alongside human-readable versions. Future you won't thank present you for a folder full of .docx files you can't open.

What if the supplier deletes their own records?

Then you have no trail, and no contract clause will resurrect it. The only defense is distributed custody—you hold copies, they hold copies, and ideally a neutral third party holds a hash. That doesn't mean blockchain for everything; sometimes a shared encrypted drive with weekly snapshots does the job. What usually breaks first is the human habit of "cleaning up" old files. Automated replication beats policy every time.

The painful version of this: supplier goes bankrupt, their IT shuts down, and suddenly your compliance documentation evaporates overnight. That happened to a client I worked with. Their suppliers' records vanished with the server auction. They lost an entire audit year and paid six figures in remediation fees. The fix wasn't legal—it was operational. We built a simple script that pulled key records every month and stored them locally.

Records only matter if you can produce them when nobody wants to help you. Independence beats access.

— former auditor, speaking about supplier insolvency

Does an audit trail survive a merger or acquisition?

Rarely intact, often salvageable. Mergers are where trails go to die—new owners bring new systems, old data sits on decommissioned servers, and nobody documents what got migrated. The ugly truth: if you're acquiring a company, assume their audit trail is incomplete until proven otherwise. Do a forensic check on record completeness before the deal closes, not after.

The trickier scenario is when you get acquired. Your carefully maintained trail may not match the new parent company's format or retention schedule. Don't fight it wholesale—map your critical records to their requirements, keep the rest in cold storage, and document the mapping. A little flexibility here saves your team from being the compliance bottleneck in integration. That said, don't let acquirers delete your historical trail just because it doesn't fit their template. You might need those records for disputes that predate the acquisition.

One more angle: contract novation. When supplier contracts transfer to new entities, audit trail clauses often get dropped in renegotiation. Redline that paragraph explicitly. Insist that records survive the transition and remain accessible to you for the original retention period. It's a small edit that prevents a massive headache later.

Small Experiments to Pressure-Test Your Audit Trail Today

Simulate a supplier exit with a mock offboarding

Pick a supplier you haven't touched in eighteen months. Now pretend they've gone bankrupt, been acquired, or simply stopped answering emails. Walk through your actual offboarding checklist—the one you'd use if they vanished tomorrow. Where do you pull the final transaction records? Who holds the encryption keys for their file shares? Do those credentials still work, or did someone rotate them during a routine cleanup last spring?

The catch is that most teams discover their audit trail was never designed for exits. It was designed for active collaboration. I have seen offboarding drills where the procurement lead couldn't even find the folder structure, let alone the data inside it. That's the point of the test. You're not looking for a clean process. You're looking for the seams—the moments where a trail that looked solid on paper turns out to be held together by one person's memory of a shared drive.

Do this with a timer running. Thirty minutes, no more. If you can't produce a readable record of the last three transactions with that supplier inside that window, you have a gap. Not a theoretical one.

Try accessing a record from an old contract

Find the oldest supplier contract you have. Not the oldest active one—the oldest one still in your archive. Open its final audit file. Not the summary report, the raw data underneath. Can you read it?

This sounds trivial until you hit the file format wall. Five-year-old CSV files usually survive. But what about the Excel files with macros that no longer run? The PDFs generated by software your company stopped licensing? The database exports that referenced a schema nobody remembers? The trick is that "accessible" in your current tech stack isn't the same as "readable in five years." I watched a team lose an entire quarter of supplier documentation because their audit system upgraded its date format and silently corrupted older records. The files existed. The data was garbage.

If you're relying on proprietary formats, export a plain-text version of the critical fields now. Yes, it's ugly. Yes, you'll lose some formatting. And yes, you'll still have a trail when the vendor's support page goes dark. That trade-off—polish versus persistence—is exactly what you're testing.

Check if your files are human-readable after five years

Here's the experiment that hurts. Print one page of your most important audit record. Wait, actually, don't print it. Open it on a device you don't use for work—an old phone, a borrowed tablet, anything without your corporate software stack. Does the data make sense to someone who wasn't in the room when you created it?

An audit trail that requires institutional memory to decode isn't an audit trail. It's a pile of clues.

— supply chain analyst, post-mortem review

What usually breaks first is the terminology. Your internal codes for suppliers, your abbreviated status fields, the shorthand you used for "pending verification"—none of that translates. A new hire, an external regulator, or your own future team will stare at a row of "AP-PND-04" and have no idea what it means. The fix isn't a glossary nobody maintains. It's a description field that spells out what happened, in plain words, right next to the code.

Most teams skip this test because it feels embarrassing. "Of course our files make sense," you tell yourself. Then you look at an actual record from five years ago and realize it references a purchase order system that was decommissioned before the pandemic. Wrong order, wrong format, wrong assumptions. That's the gap between a formal trail and a living one.

Do all three experiments on the same afternoon. The results will cluster—you'll find the same weaknesses showing up in different disguises. That's useful. That's your priority list. Fix the file formats first, then the offboarding steps, then the human readability. And set a calendar reminder for six months to repeat the whole cycle. Because audit trails don't decay on their own. They decay exactly in proportion to how long you ignore them.