> ## Documentation Index
> Fetch the complete documentation index at: https://docs.useshareable.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Share a prototype or MVP

> Put a clickable prototype, app mockup, or MVP in front of people with one link — what Shareable handles, and when you actually need app hosting like Vercel or Netlify.

You asked Claude (or ChatGPT, or v0) for "a clickable prototype of my app idea" and
got back a folder: an `index.html`, maybe a few more pages, some images. It works
when you open it locally — now you need to put it in front of a few people for
feedback. Deploying it to Vercel or Netlify works, but it's overkill: you don't want
a build pipeline and a project dashboard, you want *a link you can text someone*.

That's exactly what Shareable is for.

## What "prototype" means here

The kind of thing this guide covers — and what Shareable runs perfectly:

* **A clickable prototype** — screens that link to each other, buttons that change
  state, a multi-step flow a stakeholder can walk through.
* **An app mockup** — the UI of an app idea, fully interactive, with no real backend
  behind it yet.
* **An MVP front-end** — a real interface that talks to an *existing* API or form
  endpoint (a Google Apps Script, an Airtable form, a public API).

All of these are **static files that run in the browser**. That's the line: if it's
HTML, CSS, and JavaScript that runs client-side, Shareable hosts it as-is.

## Publish it

<Steps>
  <Step title="Drop the folder in">
    On [your pages](https://useshareable.com/pages), drag the **whole folder** Claude
    gave you (or a `.zip` of it) into the upload area. The `index.html` becomes the
    landing page; its images, CSS, and JS come along as
    [bundled assets](/guides/multi-page-decks). No need to inline anything.
  </Step>

  <Step title="Name it and create a draft">
    Give it a title. You get a private draft you can preview and click through before
    anyone else sees it.
  </Step>

  <Step title="Choose who can see it">
    Publish, then in **Share** pick an access mode — anyone with the link, a password,
    specific invited people, or anyone with a verified email. See
    [Sharing & access](/guides/sharing-and-access).
  </Step>

  <Step title="Send the link, gather feedback">
    Copy the link and send it. Turn on [comments](/cookbook/who-viewed) so reviewers
    can leave feedback right on the prototype, add a [poll](/guides/notifications) to
    ask "which direction?", and watch [analytics](/guides/analytics) to see who
    actually opened it.
  </Step>
</Steps>

<Tip>
  Prefer your agent? Ask Claude directly: *"publish this prototype to Shareable and
  give me the link."* With the [MCP server](/mcp-server) connected it uploads every
  file — pages and assets — and hands back the URL. See
  [Publish from AI](/guides/publish-from-ai).
</Tip>

## What works

Shareable serves your files raw, with no sandbox — so the prototype behaves exactly
as it does on your machine:

* **Full interactivity.** Inline `<script>`, click handlers, page transitions, canvas,
  Web Components — all of it runs.
* **Multi-page click-throughs.** Relative links between pages
  (`href="dashboard.html"`) resolve within your prototype.
* **Real assets.** Images, stylesheets, fonts, and JSON ship alongside the HTML.
* **Calls to an existing backend.** A `fetch()` to an API you already have, a form
  that POSTs to a Google Apps Script or Formspree, a public data source — these work,
  because the call happens from the viewer's browser, same as anywhere.
* **Feedback built in.** Comments, polls, view analytics, and email-on-view turn a
  prototype link into a feedback loop — the part a deploy pipeline doesn't give you.

## When you need real app hosting instead

Shareable hosts the *front end*. The moment your prototype needs a **server of its
own**, it's graduated into an app, and you want a platform like **Vercel** or
**Netlify**:

| You need…                                              | Use                          |
| ------------------------------------------------------ | ---------------------------- |
| A clickable prototype, mockup, or static MVP front-end | **Shareable**                |
| Server-side code / your own API routes / SSR           | Vercel / Netlify             |
| A database, or user accounts *for your app's users*    | Vercel / Netlify + a backend |
| A build step (Next.js build, bundler, env-var secrets) | Vercel / Netlify             |
| A custom domain per project, on a deploy pipeline      | Vercel / Netlify             |

A useful way to hold it: **Netlify and Vercel are for running apps; Shareable is for
sharing them.** If the thing already runs by opening an HTML file, you don't need a
deploy — you need a link with access control and feedback. If it needs to run code on
a server, you need the deploy.

<Note>
  **Secrets don't belong in a prototype.** Anything in your HTML or JS — including API
  keys — is visible to anyone who can open the page. That's true on any static host.
  For a prototype calling a backend, use a public/read-only endpoint or a key scoped
  to do no harm; keep real secrets server-side, which means real app hosting.
</Note>

## Make the link look right

When you paste a prototype link into iMessage or Slack, it shows a preview card. Set
the [link preview](/guides/publish-a-page#custom-link-previews-unfurls) — a title,
description, and image — from the **Share** dialog, or point `og:image` at one of your
bundled images. A polished card makes "here's my prototype" land better.