Designers Should Create Evidence Before Client Review

Why Should Designers Create Evidence Before Client Review?

A designer spends three weeks on a brand identity. Logo variations, a color system, type pairings, mockups on packaging and signage. The files go out to the client for the first round of feedback, and from that point on, the designer has no real control over where they travel next. Maybe the client loves the direction and quietly hands it to an in-house team to "finish." Maybe a stakeholder who never signed the contract claims the concept was theirs to begin with. Maybe, months later, a dispute over scope or ownership ends up in front of a lawyer, and the only thing anyone can point to is an email thread with vague timestamps and no record of what the original files actually looked like.

None of this is rare. It's one of the quieter risks of creative work, and it's almost entirely preventable not through more detailed contracts, but through a habit most designers never think to build: creating proof of a design's existence before it ever reaches a client's inbox.

The moment of maximum exposure

Client review is the point where a designer's control over their own work is lowest and the potential for dispute is highest. Files get forwarded. Screenshots get shared in Slack channels the designer isn't part of. A client's internal team sees the concept and, whether through carelessness or intent, treats it as a starting point for their own version. When that happens, the designer's only leverage is being able to show, with hard evidence, what existed and when.

This is different from copyright registration, which is slow, jurisdiction-specific, and rarely something a working designer files for every project. It's also different from a simple "created" date on a file, which can be altered, disputed, or lost entirely if the file is edited after the fact. What's needed is something closer to a digital fingerprint for copyright a record that's independent of the file itself, can't be quietly changed later, and doesn't rely on trusting a platform's internal metadata.

What a pre-review timestamp actually proves

A blockchain-anchored timestamp doesn't store or expose the design itself. It takes a cryptographic hash a unique fingerprint generated from the file's exact contents via SHA-256 hashing and anchors that fingerprint to a public blockchain ledger. Change a single pixel, a single layer, a single character of code in the file, and the hash changes completely. The ledger entry becomes an immutable file verification record: proof that a specific, unaltered version of the design existed at a specific moment, verifiable by anyone, without needing to trust Certelo, the designer, or the client's word for it.

For a freelancer or a small studio, this solves a problem that used to require expensive legal registration or none at all. For agencies working with larger clients on high-stakes rebrands, it creates a paper trail that holds up if a dispute over authorship or scope ever needs resolving formally the kind of legal proof of document authenticity that a court, an arbitrator, or an insurer can actually rely on.

Why "before review" matters more than "eventually"

Designers who do think about protecting their work often do it reactively after a dispute has already started, or after a client has already gone quiet on payment. By then, the useful window has usually closed. A timestamp created after the fact only proves the file existed as of that later date; it says nothing about what was shown to the client, or when.

Creating the record before the first share closes that gap entirely. It establishes, cleanly, that the concept existed in its current form prior to any client interaction which matters enormously if a client later claims they came up with the direction internally, or if a competing agency ends up with suspiciously similar work. It also protects against a more mundane but far more common scenario: a client disputing which round of revisions introduced which changes, and who's entitled to bill for what.

A workflow that doesn't slow anyone down

This isn't about adding a heavy compliance step to a creative process that's already tight on time. In practice, it's a single action: generate a hash of the final file a PDF export, a packaged Figma file, a rendered mockup and timestamp it before hitting send. The process takes seconds, doesn't require uploading the design itself anywhere, and leaves the designer with a verifiable record they can produce months or years later if it's ever needed. Most designers who adopt it fold it into their existing file-naming or version-control habits without noticing the extra effort.

It's also worth doing at more than one point in a project. A hash of the initial concept, another at the client-approved milestone, another at final delivery each one is a distinct piece of evidence, and together they form a timeline that's very difficult to argue with.

Common questions

Does this replace a contract or an NDA?

No. A timestamp is evidence of what existed and when — it doesn't set terms, ownership splits, or payment obligations. It works alongside a contract, not instead of one, and tends to matter most when a contract's terms are being disputed rather than absent.

Can a client tell I've timestamped a file?

No. The process doesn't touch the file the client receives or leave any visible trace in it. The hash and the blockchain record exist entirely separately from the deliverable itself.

Is this only useful if something goes wrong?

Mostly, yes but that's the point. It costs almost nothing to create and sits quietly unused in the vast majority of projects. The value shows up in the rare case where a dispute over authorship or timing actually happens, and having proof turns an unwinnable argument into a five-minute conversation.

Designers spend years building a body of work worth protecting. Taking a few seconds to timestamp it before it leaves their hands is a small habit against a real, if infrequent, risk. Certelo is a blockchain-based timestamping and proof-of-existence platform that lets creators generate this kind of verifiable record without uploading their files or trusting a third party to keep the record honest.