Skip to content

Systems and records

Business archive version collisions: when two files share one name

By SourceX Editorial · Updated

9 sections

Short answer

Never let the file name be the file's identity. Before copying anything, hash every file's content with SHA-256 and record its full original path, source system, revision ID and timestamps. Store each distinct hash once and link every location to it. Same name with different hashes means two objects to keep; same hash under two names means one object found twice. Then package and verify against a checksum manifest.

System export

Business archive version

This page covers business archive version collisions: when two files share one name.Illustrative

Key takeaways

  • File names are labels, not identities; a SHA-256 content hash is what tells two files apart.
  • Capture path, revision ID and hash in place before any copy, merge or rename, because copy tools resolve collisions by overwriting or renaming.
  • Timestamps change on copy, sync and restore and are recorded differently by FAT and NTFS, so they support version order but cannot prove it.
  • Cloud revision histories and staff knowledge expire first; export version histories, not just current files, and record who said which copy was authoritative.
  • Classify every collision as duplicate, version, different document or unresolved, keep everything unresolved, and package the result with a verified manifest.

How do you preserve distinct files with the same name but different histories?

Stop treating the file name as the file's identity. Before anything is copied or merged, compute a SHA-256 hash of every file's content and record it with the full original path, the source system, any revision or version ID the system holds, and the timestamps as found. Each distinct content hash becomes its own preserved object; each place it was found becomes a location record pointing to it. Two files that share a name but not a hash are two objects, and both are kept.

Names collide often in business archives because people reuse them: invoice.pdf, Final.docx, Pricing Model.xlsx. Windows itself warns developers not to assume case sensitivity, treating OSCAR, Oscar and oscar as the same name even though POSIX-style file systems can hold all three as different files. When folders from different systems are merged into one export, the copy tool has to overwrite, skip or rename, and every one of those choices can erase history unless content identity was captured first.

The protocol below is built for a deadline: a company winding down, a system being retired or an acquired business whose drives are about to be decommissioned. It aims to produce an archive in which every version that existed can still be found, told apart and proven unchanged.

Where same-name collisions come from in a business archive

Many collisions come from a handful of ordinary habits and tools. Knowing the source tells you which signal will expose it.

Where same-name collisions come from in a business archive
SourceHow the collision arisesWhat is lost if the name winsSignal that exposes it
Case-only differencesA share that kept Report.pdf and report.pdf is copied to a case-insensitive drive or zipOne file silently replaces the otherTwo paths that match when lowercased
Folder flatteningAn export tool writes every attachment or document into one folderFiles from different projects overwrite each otherFewer files exported than the source reports
Cloud revision historyDrive or SharePoint keeps several versions under one name; a plain download takes only the current oneEvery earlier state of the documentRevision count above one in the source system
Generic attachment namesEmail and scanner software name files scan001.pdf or invoice.pdfUnrelated documents merged into oneSame name, different sizes or hashes
Personal copiesStaff keep their own Final or v2 of a shared template on desktops and drivesThe working variants that show how a decision evolvedSame name under different user folders
Restore over live dataA backup restore writes older files over newer ones with the same nameThe newer contentHash mismatch against a pre-restore inventory
Branch or site copiesEach office keeps its own price list or SOP with an identical nameLocal differences in terms, prices or procedureSame name under different site roots

Why dates and names cannot settle which copy is which

Timestamps and names describe where a file sat and when a system last touched it; they do not prove what it contains or which copy came first. Only a content hash does that, and only for content, so the hash and the context have to be kept together.

Microsoft's documentation shows how weak timestamps are as evidence. On FAT volumes, write time has a resolution of two seconds and times are stored in local time, while NTFS stores UTC, so a file saved at one moment can display different times depending on the volume and the time zone it is read in. NTFS can delay last-access updates by up to an hour, and the SetFileTime function lets a program change creation, access and write times without changing the content. A modified date that looks newer may simply reflect a copy, a sync or a restore.

A cryptographic hash avoids those problems. NIST SP 800-107 Revision 1, which NIST announced in 2022 it will withdraw once its remaining requirements move to new validation guidance, defines a collision as two different messages with the same digest and gives SHA-256 an expected collision resistance of 128 bits, which is why two files with different SHA-256 values can be treated as different content and two files with the same value as the same content for archive purposes.

What evidence disappears if preservation waits?

Version history held inside cloud systems is the first thing to go, followed by the people who know which copy was the real one. Capture both before any account is downgraded, deleted or handed to a liquidator.

Google's Drive API documentation says revisions of uploaded files that are not marked to keep forever are typically preserved for 30 days and can be purged earlier once a file has 100 such revisions and a new one is uploaded; at most 200 revisions per file can be marked keep forever. Microsoft documents that the default organization setting for new SharePoint libraries keeps 500 major versions with no expiration, and that changing the organization default does not change libraries that already exist, so each library's own limit must be checked. Version limits, retention settings and account deletion dates vary, so read the current settings for each system rather than assuming a default.

The human evidence is just as perishable. The finance lead who knows that the pricing model in the shared drive was superseded by a copy on her laptop may be gone in a week. Record that knowledge as a short note attached to the collision, with the person's role and the date.

  • Cloud revision histories that a plain download does not include.
  • Per-user folders, desktops and laptops scheduled for wipe or return.
  • Admin access needed to export version histories rather than current files.
  • Staff explanations of which copy was authoritative and why.
  • Original paths, which disappear once files are moved into a new structure.

The file identity and version collision protocol

Run these steps in order. Each produces a record the next step relies on, and none of them renames or moves an original until its identity has been captured.

At a glance

The file identity and version collision protocol

  • Freeze and inventory: list every source (file shares, cloud drives, mailboxes, laptops) with an owner, an access deadline and the export method that keeps version history.
  • Capture identity in place: for every file, read the full original path, size, timestamps, any system revision or version ID, and compute SHA-256 of the content before copying.
  • Export version histories, not just current files, wherever the source system holds them, and record each revision as its own file instance with its revision ID.
  • Store by content: write each distinct hash once into the archive under a stable identifier derived from the hash, so no later copy can overwrite it.
  • Record locations: for every instance, write a location record linking the original path, system and revision ID to the stored object.
  • Detect collisions: group instances by case-folded file name and compare hashes within each group; group by hash and compare names and paths.
  • Classify each group as duplicate copies, versions of one document or different documents, using the decision table below, and record the reason.
  • Order versions by system revision IDs and version metadata where they exist, and only then by timestamps, noting which evidence was used.
  • Attach context: staff notes, related emails or tickets, and the application needed to open each format.
  • Package and verify: build a manifest of every stored object with its checksum, validate the package, and keep the validation output with the archive.

The identity record kept for every file instance

Every instance found during the inventory gets one row in the identity register. The structure follows the logic of the PREMIS preservation metadata dictionary maintained at the Library of Congress, which treats an object identifier as mandatory, stores a message digest and its algorithm for fixity checks, and records derivation relationships between objects. The example values are illustrative.

The identity record kept for every file instance
FieldWhat it holdsWhy it mattersIllustrative value
object_idIdentifier for the stored content, derived from its hashLets many locations point to one objectsha256 followed by the first 16 hex characters
sha256Full content hash computed at captureProves content identity and later fixity64 hex characters
source_systemWhere the instance was foundSeparates drive, mailbox and laptop copiesShared drive, finance share
original_pathFull path exactly as found, case preservedDistinguishes same-name files and keeps contextFinance/2024/Pricing Model.xlsx
revision_idSystem revision or version number, if anyOrders versions without trusting datesVersion 14.0
timestamps_as_foundCreated and modified times with time zone and file systemContext, not proof of orderModified 2024-03-02 UTC, NTFS
relationshipLink to another object: version of, copy of, derived fromRebuilds the history across namesVersion of object with hash ending 9c2e
context_noteStaff explanation, author role and dateRecords which copy was authoritativeFinance lead: laptop copy superseded drive copy

Reading a collision: duplicate, version or different document?

A collision only becomes a decision once name, hash and path are read together. Apply the first row that matches and write the result into the relationship field.

Reading a collision: duplicate, version or different document?
NameContent hashPath and system evidenceInterpretation and action
Same nameSame hashDifferent folders or systemsDuplicate copies: store once, keep every location record
Same nameDifferent hashSame path, different revision IDsVersions of one document: keep all, order by revision ID
Same nameDifferent hashDifferent folders, projects or usersDifferent documents: keep both, never merge
Names differ only by caseDifferent hashCame from a case-sensitive sourceDifferent documents: keep both, record the exact case
Different namesSame hashAnyRenamed copy: store once, record both names
Same nameDifferent hashNo revision IDs, conflicting datesUnresolved: keep both, ask the owner, mark the order unknown

Illustrative case: three pricing workbooks with one name, and an exception

Illustrative only, with invented details: a distributor is closing and finds three files named Pricing Model.xlsx, one on the finance share, one in a sales manager's cloud drive and one on a laptop. The shared drive copy and the cloud copy have the same hash, so they are one object found in two places. The laptop copy has a different hash, and the cloud drive reports 23 revisions (an illustrative count) behind the current version.

The protocol keeps two stored objects from the current files and 23 more from the exported revision history, each with its revision ID. The finance lead's note says the laptop copy holds the margin rules used in the final year. Without the protocol, a merge into one folder would have kept whichever copy was written last, and the most recent margin logic could have been lost.

One exception deserves its own rule. Some files change their bytes every time they are opened or saved even when nobody changed the content, such as certain database files or documents an application re-stamps on save. Their hashes differ while their meaning does not. Keep each instance as the protocol requires, but flag the group as possible re-save variants and, where the format allows, compare an extracted text or data rendering before calling them different versions. Do not delete any of them on that comparison alone.

Packaging the result so it can be checked later

Package the archive so anyone can later prove it is complete and unchanged. RFC 8493 defines BagIt, a packaging format in which a payload manifest lists every payload file with a checksum and a bag is valid only when every checksum verifies. The Library of Congress bagit-python tool generates SHA-256 and SHA-512 manifests by default and has a validate option; its fast mode checks only the file count and byte total, so run a full validation before relying on the package.

Keep the identity register, the collision decisions and the validation output inside the package, so a later reader sees not just the files but why each one is there. Preserving an archive this way does not by itself create any right to license it; access, privacy permission, ownership and contractual licensing rights are separate questions that the records' contracts and notices decide.

Should the archive later be offered for licensing, a brief SourceX company assessment comes first and nothing has to be uploaded for it. Big deliveries are not moved into SourceX hosting; they remain in the company's storage or go out on encrypted drives, so a verified archive can stay where it was built.

Frequently asked questions

Can I just let the copy tool rename duplicates to file (1) and file (2)?

Only after identity has been captured. Automatic renaming keeps both files but loses the original path and any sign of which is a version of which. Record the path, hash and revision ID first, and the rename becomes harmless.

Is MD5 good enough for finding duplicates?

Use SHA-256 for the archive's identity and fixity records. RFC 8493 requires BagIt tools to support SHA-256 and SHA-512 and keeps MD5 and SHA-1 only for compatibility. A weaker hash may still be computed alongside if an older system needs it.

Should we keep every version or only the latest one?

Keep every distinct version you can export when the history may matter later, because earlier versions show how terms, prices or procedures changed. Duplicate copies with the same hash cost almost nothing to keep as location records, so the extra storage is mostly the real versions.

Does a newer modified date prove which file is the latest?

No. Copies, syncs and restores can change dates, file systems record time differently, and programs can set file times without changing content. Use system revision IDs where they exist and treat dates as supporting context.

What if the owner of a file has already left?

Keep every colliding version, mark the order as unknown and record what evidence exists, such as emails that attach one version. An unresolved collision kept intact is better than a guess that deletes history.

Sources

  • Microsoft's file naming guidance says not to assume case sensitivity, treating OSCAR, Oscar and oscar as the same name, while POSIX-compliant file systems may treat them as different. Source
  • Microsoft documents that FAT records write time at two-second resolution in local time, NTFS records UTC and can delay last-access updates by up to an hour, and SetFileTime changes file times without changing content. Source
  • NIST SP 800-107 Revision 1 defines a hash collision as two different messages with the same digest and gives SHA-256 an expected collision resistance of 128 bits. Source
  • Google's Drive API guide says purgeable revisions are typically kept 30 days, can be purged earlier at 100 revisions, and up to 200 revisions can be marked keep forever. Source
  • Microsoft says the default organization version limit for new SharePoint libraries is 500 major versions with no expiration, and that changing it does not update existing libraries. Source
  • The PREMIS Data Dictionary 3.0 treats fixity as a stored message digest and algorithm for later comparison and defines identifiers and derivation relationships between objects. Source
  • RFC 8493 (BagIt 1.0) requires a payload manifest listing every payload file with a checksum and defines a valid bag as one whose every checksum verifies. Source
  • The Library of Congress bagit-python tool generates SHA-256 and SHA-512 manifests by default, validates bags, and in fast mode checks only file count and byte total. Source
  • NIST announced in December 2022 that it will withdraw SP 800-107 Revision 1 after moving its remaining requirements into new Cryptographic Module Validation Program guidance. Source

See if your company qualifies

A short company assessment. No data uploads are needed.

See if your company qualifies