What Should Creators Do Before Sending Files to Clients?

What Should Creators Do Before Sending Files to Clients?

The moment a file leaves your hands, you lose a little bit of control over it. A designer emails over a set of mockups. A developer shares a working demo. A photographer sends a gallery of proofs. A copywriter attaches a first draft. In each case, the creator has just handed a client something valuable and, if things go sideways later, something that's suddenly hard to prove was theirs to begin with.

This isn't a hypothetical worry. Scope disputes, late payments, unauthorized reuse, and "who actually made this first" arguments are some of the most common friction points between creators and clients. And they almost always come down to the same missing piece: nobody can say, with certainty, what existed and when.

The gap between "I made this" and "I can prove I made this"

Most creators assume that having the original file is proof enough. In practice, a file on your laptop proves very little on its own. File metadata can be edited. Creation dates can be spoofed or simply reset when a file is copied between devices. Cloud storage timestamps reflect upload time, not creation time, and can be manipulated by anyone with access to the account.

If a client later claims they came up with the concept, or a competitor lifts unreleased work and publishes it first, "I have the file" isn't a defense. What holds up is independent, third-party evidence that the file existed in its current form at a specific point in time evidence you didn't generate yourself and can't be accused of backdating.

That's the entire idea behind a secure timestamp API: an outside system, not the creator and not the client, records a cryptographic fingerprint of the file and anchors it to a public, tamper-evident record. Nobody including the creator can quietly alter that record after the fact.

The five-minute habit that prevents months of arguments

Before a single file goes out the door, it's worth building in a short, repeatable step: generate a hash of the file, timestamp it, and keep the resulting record somewhere safe. This isn't about distrust of any particular client it's a professional habit, the same way a contractor photographs a job site before starting work.

Here's roughly what that looks like in practice:

• Hash the file. A SHA-256 file hashing process converts the document, image, code repository, or audio file into a unique fingerprint. Change even one pixel or one line of text, and the fingerprint changes completely.

• Timestamp the fingerprint, not the file. The fingerprint not the actual content gets anchored to a blockchain ledger. This means creators never have to upload sensitive, unreleased, or confidential work to a third party just to prove it exists.

• Keep the certificate. The resulting timestamp certificate becomes portable proof: an independently verifiable record showing that specific file, in that specific state, existed at that specific moment.

• Then send the file. Only after this record exists does the file go to the client.

The sequence matters. Proof created after a dispute starts is far less convincing than proof created as routine practice, before there was ever a reason to need it.

Why this matters differently across creative disciplines

A designer sending early concept boards is protecting against a client who takes the direction to a cheaper freelancer mid-project. Digital proof of design creation, tied to a timestamp, makes the design lineage clear which version came first, and who produced it.

A developer sharing a demo build is protecting intellectual property and proving code ownership at a specific commit, before a client or a competing contractor claims the architecture as their own.

A photographer sending low-res proofs before the final sale is establishing that the images, at full resolution, existed before the client ever saw them, closing off any claim that the client "already had" the shots.

A writer or copywriter sending a first draft is documenting authorship of language and structure before revisions, edits, or a change in scope blur who wrote what.

The specifics differ, but the underlying need is identical: legal proof of document authenticity that doesn't depend on anyone's memory or goodwill six months later.

What this looks like if a dispute actually happens

Say a client stops responding after receiving deliverables, then resurfaces months later claiming the work was never delivered in that form, or that they came up with elements of it independently. Without a timestamp, this becomes a matter of conflicting accounts. With one, the creator can produce an immutable file hash verification record showing the exact file, the exact content, and the exact date verifiable by anyone, including a mediator, an attorney, or a court, without needing to trust the creator's word or the platform that hosts the proof.

This is also where the copyright infringement angle becomes practical rather than theoretical. If a client or anyone else publishes the work without authorization, the timestamp becomes the anchor for a claim: proof that the creator's version predates the unauthorized one.

Making it part of the workflow, not an afterthought

The creators who benefit most from this aren't the ones who timestamp files reactively, after a relationship has already turned adversarial. They're the ones who treat it as a standard pre-delivery step, the same way they'd back up a project file or save a version history. It costs a few minutes. It requires no special technical knowledge. And it means that if a dispute ever does arise, the creator isn't scrambling to reconstruct a timeline from memory they already have it, dated and verifiable.

Certelo gives creators an independent, blockchain-based way to timestamp and verify their work before it ever leaves their hands quiet, routine proof that's there if they ever need it.