# How do you share a Lovable app with a client and know if they opened it?

- URL: https://getroomi.com/guides/how-to-share-a-lovable-app-with-a-client
- Updated: 2026-10-12

Lovable can publish your app and show visits in total, but not which person opened it. To know whether a particular client looked, give them their own link. With Roomi, you deploy a copy of the app on sample data and make a private link in the client’s name. Then you see when they opened it, and what held them.

This guide covers what Lovable shows you and which of its two kinds of project you have. Then the backend, and the steps to put the app in a room. It ends with what you see once your client opens it. It assumes the app works in Lovable already.

## Lovable’s link and a room, side by side

| | Lovable, published | Lovable, invite only | A Roomi room |
|---|---|---|---|
| Who can open it | Anyone with the address | People you invite | The person whose link it is, and anyone they say they passed it to |
| Your client needs an account | No | Yes, a Lovable one | No |
| Tells you which person opened it | No: visits in total | No: visits in total | Yes, by name |
| Shows where each person’s time went | No | No | Yes, screen by screen |
| Data behind it | Your app’s own backend | Your app’s own backend | Sample data only |

## What does Lovable show you today?

Lovable’s project analytics count visits, page views, visit length, sources, devices and countries. They measure overall traffic, not individual people, so they cannot tell you which person opened your app. So a published Lovable app cannot tell you whether a particular client opened it, or what they did there.

On Lovable’s Free and Pro plans, a published app is open to anyone with its address by default; “Invite only” limits it to people you add, who must log in.

That is enough for a public launch page, where you want to know how many came and from where. It is not enough when you have sent the app to five prospects and need to know which two looked. For that you need a link per person. [The best ways to share an app built with AI](https://getroomi.com/guides/best-ways-to-share-a-vibe-coded-app-with-a-client) compares the other routes.

## Why does a link per person matter?

A link made for one person turns a visit into a name. You see that Priya opened it on Tuesday, spent most of her time on the pricing screen and came back on Thursday. If she forwards it, the next person is asked who they are, and you see them too.

- **A view with a name.** Each link carries the name of the person you made it for, and the room greets them by it.
- **Forwarding made visible.** Whoever opens a forwarded link is asked “Are you Priya Shah?”, and someone who says no gives their own name.
- **One link off, the rest untouched.** Revoke or expire one person’s link without touching anyone else’s.

[Sharing a private link](https://getroomi.com/docs/sharing) covers every option.

## Which kind of Lovable project do you have?

Since 13 May 2026, new Lovable projects are rendered on a server, built on TanStack Start. Earlier ones were single-page apps deployed as static files. The kind decides how your app runs on Roomi, and which plan it needs. Here is how to tell.

Lovable says a TanStack Start project lists @tanstack/react-start in its package.json and needs a host that runs its server, while an older React and Vite project builds to static files. You can also ask Lovable in the project chat which stack it uses.

| Your project | How to tell | On Roomi | Plan |
|---|---|---|---|
| TanStack Start, made since 13 May 2026 | `@tanstack/react-start` is in `package.json` | A container demo: a copy of its own for each viewer link | Pro and up |
| React and Vite, made earlier | No `@tanstack/react-start` in `package.json` | A static demo: the built files | Every plan |

If you are not sure, ask Lovable in the project chat: “Which stack does this project use, older React + Vite or TanStack Start?”

An older Lovable project, built with React and Vite, builds to static files, so on Roomi it is a static demo, which runs on every plan, Free included. A TanStack Start app needs its server, so on Roomi it runs as a container demo, on Pro or above. [Static demos](https://getroomi.com/docs/static) and [container demos](https://getroomi.com/docs/containers) explain each.

## What about the backend?

If your app in Lovable uses a backend, such as Lovable Cloud, that backend holds real accounts and records. The copy you send a client never touches it. It runs on sample data shaped like the real thing, so your client can click anything and change anything, and nothing reaches a real system.

A Lovable app on Roomi runs on sample data, never on its live Lovable Cloud backend. Every demo runs on mock data, and a container demo has no internet to reach one.

1. Ask Lovable, or your coding agent, to make a demo version that reads its data from sample files in the app instead of the backend.
2. Fill those files with invented names, figures and records that look like your client’s world. [Swapping real data for mock data](https://getroomi.com/guides/how-to-use-mock-data-in-an-ai-built-demo) shows four ways to do it.
3. Take out any keys. The deploy scans for secrets and stops if it finds one, but it is better that none is there. A project on Supabase may keep its key in `src/integrations/supabase/client.ts`, and the deploy stops on that one too.
4. Check the demo version in Lovable’s preview before you deploy it anywhere.

## Put the app in a room

You deploy from your own machine, with the Roomi command line and a coding agent such as Claude Code or Cursor to do the technical part. Every command rehearses first, and nothing goes live until you add `--commit`.

1. **Get the code.** On every Lovable plan, Git sync keeps a project in step with a repository on GitHub, GitLab or Bitbucket. Downloading the code once, as a zip file, is on the paid plans. Open the repository on your machine with your coding agent.
2. **Install Roomi.** Run `npm install -g @getroomi/cli`, then `roomi login`, which opens your browser for you to approve. [Install the CLI](https://getroomi.com/docs/install) has the details.
3. **For a TanStack Start project, make it a container first.** It needs a Node server build (TanStack’s own Nitro plugin makes one), a health route and a Dockerfile, before `roomi init` reads it. An older Vite project skips this step. For a TanStack Start one, ask your agent: “Make this app a container demo for Roomi, keeping to the build contract at https://getroomi.com/docs/containers.”
4. **Describe the demo.** Run `roomi init`. It writes `pitch.json`, and `PITCH.md`, the guide your agent follows from then on. It takes the demo’s name from `package.json`, which a generated project often leaves as its template’s, so check `name` in `pitch.json`.
5. **Write the tour.** Three to six steps, one idea each, in the order you would pitch it. Your agent can draft it for you to change. In an older Vite project, a step opens the app’s first page, not a screen its router draws, such as `/clients`: say where to click instead.
6. **Rehearse.** Run `roomi deploy`. It checks the description, scans for secrets, builds the app, checks every step of the tour, and shows what would go live.
7. **Publish.** Read the rehearsal, then run `roomi deploy --commit`.
8. **Make a link for your client.** Run `roomi link "Priya Shah" --expires 14`, and send the address yourself.

Say in your message that the room shows you what they look at: Roomi’s [terms](https://getroomi.com/terms) ask you to tell each viewer that it logs what they do there. [The checklist for an app built with AI](https://getroomi.com/guides/is-it-safe-to-send-a-client-an-ai-built-app) covers the rest of what to check first.

In Claude Code, the Roomi plugin runs all of this when you say “deploy it to roomi”, and asks you before it publishes. [Build with your AI agent](https://getroomi.com/docs/ai-agents) covers the files `roomi init` leaves for your agent.

## How do you see if they opened it?

Open the project in the Roomi app. Each link’s card on the pipeline moves from sent to opened to engaged as your client uses it, and their journey shows every visit, screen by screen. You hear by email when they first open it, and the app tells you when they come back.

| Stage | What it means |
|---|---|
| Sent | The link has not been opened |
| Opened | One visit |
| Engaged | Two or more visits, two minutes or more inside, or a question or a colleague named |
| Said yes | They booked a meeting, or asked for the proposal |
| Later | They said “Get back to me” |
| Not now | They said “Not for me” |

Their journey shows when they came, how long they spent on each screen and page, how far through the tour they got, and anything they said. Who to call first, on the project’s Overview, names the person most worth a call today, with the evidence. [Analytics and the pipeline](https://getroomi.com/docs/analytics) has every measure, and [agencies](https://getroomi.com/use-cases/agencies) shows how a studio uses it with several clients at once.

## Questions people ask

### Can I see who viewed my Lovable app?

Not person by person in Lovable’s own analytics, which count visits rather than people. To see which client opened it, give each one a private link of their own, so every visit is filed under a name.

### Do I have to leave Lovable?

No. Keep building in Lovable as you do now. You put a copy of the app on Roomi for clients to see, and deploy it again whenever you have changed something worth showing.

### Will my Lovable Cloud data be exposed?

No, because it is never there. The copy on Roomi runs on sample data, and the deploy stops if it finds anything that looks like a live key. A container demo has no internet, so it cannot reach your backend.

### Does my client need an account?

Not for Roomi. They open their own link in a browser and the room opens, with nothing to sign up for or install. An invite-only Lovable app is different: whoever you invite has to log in to Lovable.

### Which Roomi plan do I need?

Pro, for a private link per client and everything each one did. A project made since 13 May 2026 also needs Pro for its container demo. An older Vite project runs on Free too, as a draft or a public listing.

## Sources

- Lovable: [docs.lovable.dev/features/analytics](https://docs.lovable.dev/features/analytics), checked 12 October 2026

- Lovable: [docs.lovable.dev/features/publish](https://docs.lovable.dev/features/publish), checked 12 October 2026

- Lovable: [lovable.dev/blog/building-apps-using-tanstack-start](https://lovable.dev/blog/building-apps-using-tanstack-start), checked 12 October 2026

- Lovable: [docs.lovable.dev/tips-tricks/external-deployment-hosting](https://docs.lovable.dev/tips-tricks/external-deployment-hosting), checked 12 October 2026

## About the author

**[Kaz Kato](https://getroomi.com/about)**, Co-founder & CTO, Roomi. Kaz co-founded Roomi with Tesh, whom he has built with since 2017: two startups that failed, one venture studio that didn’t, and an exit.

## Related guides

- [What is the best way to share an app you built with AI with a client?](https://getroomi.com/guides/best-ways-to-share-a-vibe-coded-app-with-a-client)

- [How do you swap real data for mock data in a demo built with AI?](https://getroomi.com/guides/how-to-use-mock-data-in-an-ai-built-demo)

- [Is it safe to send a client a link to an app you built with AI? A checklist](https://getroomi.com/guides/is-it-safe-to-send-a-client-an-ai-built-app)