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
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.
| Source | How the collision arises | What is lost if the name wins | Signal that exposes it |
|---|---|---|---|
| Case-only differences | A share that kept Report.pdf and report.pdf is copied to a case-insensitive drive or zip | One file silently replaces the other | Two paths that match when lowercased |
| Folder flattening | An export tool writes every attachment or document into one folder | Files from different projects overwrite each other | Fewer files exported than the source reports |
| Cloud revision history | Drive or SharePoint keeps several versions under one name; a plain download takes only the current one | Every earlier state of the document | Revision count above one in the source system |
| Generic attachment names | Email and scanner software name files scan001.pdf or invoice.pdf | Unrelated documents merged into one | Same name, different sizes or hashes |
| Personal copies | Staff keep their own Final or v2 of a shared template on desktops and drives | The working variants that show how a decision evolved | Same name under different user folders |
| Restore over live data | A backup restore writes older files over newer ones with the same name | The newer content | Hash mismatch against a pre-restore inventory |
| Branch or site copies | Each office keeps its own price list or SOP with an identical name | Local differences in terms, prices or procedure | Same 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.
| Field | What it holds | Why it matters | Illustrative value |
|---|---|---|---|
| object_id | Identifier for the stored content, derived from its hash | Lets many locations point to one object | sha256 followed by the first 16 hex characters |
| sha256 | Full content hash computed at capture | Proves content identity and later fixity | 64 hex characters |
| source_system | Where the instance was found | Separates drive, mailbox and laptop copies | Shared drive, finance share |
| original_path | Full path exactly as found, case preserved | Distinguishes same-name files and keeps context | Finance/2024/Pricing Model.xlsx |
| revision_id | System revision or version number, if any | Orders versions without trusting dates | Version 14.0 |
| timestamps_as_found | Created and modified times with time zone and file system | Context, not proof of order | Modified 2024-03-02 UTC, NTFS |
| relationship | Link to another object: version of, copy of, derived from | Rebuilds the history across names | Version of object with hash ending 9c2e |
| context_note | Staff explanation, author role and date | Records which copy was authoritative | Finance 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.
| Name | Content hash | Path and system evidence | Interpretation and action |
|---|---|---|---|
| Same name | Same hash | Different folders or systems | Duplicate copies: store once, keep every location record |
| Same name | Different hash | Same path, different revision IDs | Versions of one document: keep all, order by revision ID |
| Same name | Different hash | Different folders, projects or users | Different documents: keep both, never merge |
| Names differ only by case | Different hash | Came from a case-sensitive source | Different documents: keep both, record the exact case |
| Different names | Same hash | Any | Renamed copy: store once, record both names |
| Same name | Different hash | No revision IDs, conflicting dates | Unresolved: 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.