A Loom or screenshot shows the reviewer your build. A live private link lets them click through it themselves. Here's exactly what each format loses in transit — and when a recording is still the right call.
You finished a build and you want eyes on it. Two reflexes: record a quick walkthrough, or drop the file somewhere and send a link. They feel interchangeable — both end in "here, take a look." They are not. They lose different things on the way to the reviewer, and the thing each one loses decides the quality of the feedback that comes back.
This post is only about that one transaction — getting a build reviewed. Not marketing, not documentation. Review. With that frame fixed, here's the honest accounting, format by format.
A screen recording — a Loom, a GIF, a stack of screenshots — is a flattened performance. You drove the build once, narrated your own path through it, and froze that path into video. The reviewer watches you use the thing. They never use it.
That's a real feature in some cases. You control the order. You can talk over the confusing part. Nothing renders wrong on their machine because nothing renders on their machine at all — it already rendered on yours. For a pitch, a feature highlight, or an async explainer where your voice is the deliverable, that control is exactly right.
But three things die in the flattening.
It loses interactivity. The reviewer can't hover the button to see the state change, can't tab through the form, can't open it on the phone in their pocket to check the layout that worried them. They can only watch the states you triggered, in the order you triggered them. Every "what happens if I…" goes unanswered, because the only person who could try it was you, two days ago.
It loses current-ness. A recording is stale the moment you ship the next change. You fix the header, and now the recording shows the old header — so you re-record, or you caption "ignore the header, that's fixed," and the reviewer is now mentally diffing your video against a build they can't see. Across three rounds of revisions you've recorded the same flow three times.
It loses exact-spot feedback. This is the quiet one. The notes come back as "around 0:47 the card felt heavy" or "the thing on the right, not sure which." A timestamp points at a moment in your video. It does not point at an element in the build. You become the translator, mapping every vague reference back onto the actual page — and that translation is where briefs go wrong.
Drop your HTML build, get a private, unguessable link, and let the reviewer click through the real thing on their own device. No account for them, no card for you.
A live link hands over the artifact, not a film of it. The reviewer opens the actual page and drives it themselves — clicks the states, types into the form, shrinks the window, tries the path you didn't think to record. They're not watching your demo; they're stress-testing your build.
What that buys you:
They find what you'd never have filmed. The reviewer's instinct is to click the thing you didn't. That's where the real bugs live — the empty state, the long name that wraps, the mobile breakpoint. A recording can only surface problems you already walked past. A live link surfaces the ones you didn't know to look for.
It's never stale. Replace the file, the link stays the same. The reviewer reopens the same URL and sees the current version. No re-recording, no "ignore the header" captions, no diffing.
Feedback pins to the element. With Review turned on, anyone with the link clicks the exact spot and leaves a note — no account, no install. The note sticks to that element, on the screen size they were viewing. "0:47" becomes "this card, on mobile," anchored where it belongs. Enabling Review and collecting pinned comments is on every plan; exporting the thread as a brief — element anchors intact, ready to hand to the AI that built it — is a Studio feature.
And the privacy worry that makes people reach for a recording in the first place? It doesn't apply. A live link here is private and unguessable by default, set to noindex — "anyone can open it" means anyone you sent it to, not the public. Add a password or an expiry if the work is sensitive. You don't trade privacy for interactivity.
This isn't a one-sided pitch, so here's the other column honestly.
It loses narration. A link doesn't talk. If the value of the share is you explaining — the reasoning, the order, the "watch what happens here" — a silent page won't carry that. Pair the link with a short recording, or write a note. The link shows; it doesn't tell.
It loses fixed order. The reviewer wanders. For a pitch where the sequence is the persuasion, that's a downside — you wanted them to see B after A, and they opened C first.
It loses the things that aren't a clickable page at all. This is the real boundary. A live link works when the artifact is a self-contained web page — an HTML build, a client prototype, a Lovable app. It does not work for a native desktop or mobile app, a flow locked behind an auth wall you don't want to provision, or a long backend job. For those, record it — the recording is the only way to hand the experience over at all.
And if the thing genuinely needs a running server, a database, or auth to be testable, that's not a link's job either — that's a deploy platform's. Vercel or Netlify host the live app; a private link covers the static slice you share for review. Own the boundary; don't pretend a link is a backend.
Ask one question: does the reviewer need to use the thing, or watch you use it?
Most of the time, the thing you just built is a clickable web page, and you reach for the recording out of habit — because hosting felt like a step. It isn't anymore. The link is the same drag-and-drop reflex as hitting record, and it hands over the real build instead of a film of it. Pick the format by what you need back, not by which reflex fires first — and if you're not sure, start with the link.
A private link and a public deploy are the two ends of one dial: how findable the page should be. A job-by-job map of where each endpoint fits, plus the in-between cases most real work actually lands in.
A sandbox preview link is bound to a live session and a project you keep open. A private link is a finished artifact. Here's exactly when the preview stops being the right thing to send — and what to send instead.
Cloudflare Pages is a public, global CDN site — built to be found and to scale. A private link is built to reach a named audience and nobody else. They solve opposite halves of "I made a page, now what." Here's the honest fit for each, where the backend boundary sits, and how to pick in one question.
miinideck turns a single HTML file into an unguessable link with optional password and expiry. Default-private, never indexed.