Skip to content

Build and share a web app with Lovable

Describe an app in plain English, Lovable builds it — multiple pages, with a login and a real database behind it — then you publish it to a live link anyone can open in their browser. Want others to build on it? Turn on remixing and they copy the whole thing into their own account.

Time: the build is a chat conversation; the publish is one click. The catches: Lovable is its own web app — you do the describing and the publish click, your coding agent isn't the actor. The free plan gives 5 credits a day, max 30 a month (one message can cost less than one credit or several), and a custom domain needs a paid plan. [confirmed] Last verified: 2026-06-07 · button names, credit limits, and plan rules come from docs.lovable.dev and lovable.dev/pricing. [confirmed]

Before you begin

  • A Lovable account, signed in at lovable.dev. Sign up free with email, Google, GitHub, or Apple — ~3 min, anyone with an email can. You land on the free plan with 5 daily credits straight away. [confirmed]
  • Know which of the two shares you want: a link to the running app (anyone clicks it, no Lovable account to view a public one), or a remixable copy (someone copies the whole project into their own Lovable account to change). These are different settings — see the steps. [confirmed]
  • For a custom domain or a workspace-only (org) app: a paid plan. Pro is $25/mo (100 monthly credits, still 5 daily) and unlocks custom domains. [confirmed]

New to Lovable? Lovable is its own AI app builder — you do the typing here, not your coding agent. Open lovable.dev, type what you want into the prompt box on the home page ("build me a one-page event sign-up with a form and an admin list"), and you'll land in the project editor that every step below acts on.

Build it: describe the app in chat

You build by talking to Lovable in the chat panel on the left of the editor — no commands, no files.

  1. Describe the whole app in one go, then refine. Lovable generates working pages from your description and shows a live preview on the right. [confirmed]

    Build a volunteer sign-up app: a public page with a form
(name, email, which shift), and a private admin page that lists
everyone who signed up. Add email login for the admin page.

  2. Add a backend when you need to store or log in. The moment your app needs to save data (sign-ups, submissions, accounts), Lovable connects a real database and authentication through its built-in Supabase integration — a cloud database, user logins, and file storage, set up from the chat. Open project settings → Integrations → Supabase tab → Connect Supabase to authorize it once. [confirmed]

  3. Keep refining in chat. "Make the admin table sortable", "add a thank-you screen after sign-up." Each message spends credits by complexity — a tiny tweak is a fraction of a credit, a whole new page is a couple. [confirmed]

The preview is not the live app yet. The right-hand preview shows what you're building. Nobody else can reach it until you Publish (next). And after you publish, later edits don't go live automatically — you re-publish to push them. [confirmed]

  1. Click Publish — the icon in the top-right of the editor opens the Publish modal. [confirmed]
  2. Set the website address (or leave it blank and Lovable auto-generates one). Your app goes live at a .lovable.app URL. [confirmed]
  3. Set who can access it: [confirmed]
    • Public — anyone with the link opens and uses the app, no Lovable account needed.
    • Workspace — only people in your workspace, after they sign in. Business/Enterprise plans only. [confirmed]
  4. Click Publish. Lovable runs a quick security scan, then deploys a snapshot of your app. A minute or so later the link is live. Copy it and send it. [confirmed]
  5. Pushed a change? Re-publish. Edits stay in the preview until you click Publish → Update; the same URL then serves the new version — no new link to send. [confirmed]

Let others copy it: remixing

A remix is a complete copy of your project — every page, the layout, the chat history — dropped into someone else's Lovable account, theirs to change without touching your original. [confirmed]

  • Sharing the live link does not hand over the project. Visitors to your published URL use the running app; they can't see or edit the code behind it. Remixing is a separate, opt-in thing. [confirmed]
  • Turn it on: in the Share settings, enable public remixing. Then anyone who opens the project can hit Remix and get their own copy. [confirmed]
  • One honest limit: you can only remix a project that isn't connected to a backend (Supabase). So a static front-end remixes cleanly; an app with a live database and logins does not — Lovable blocks it to avoid handing over your data connection. [confirmed]

Free vs paid — what you actually get

  • Free plan: build, publish, and let people view or remix your apps — all free. The real limit is build effort: 5 credits a day, capped at 30 a month, resetting at midnight UTC and not rolling over. A small app fits; a big one will make you wait for tomorrow's credits or upgrade. [confirmed]
  • Pro ($25/mo): 100 monthly credits (still 5 daily), plus custom domains and removal of the Lovable badge. [confirmed]
  • Custom domain = paid only. Your own myorg.org instead of something.lovable.app needs Pro or above. The free .lovable.app link works fine for everyone; it just isn't branded. [confirmed]
  • Whether the free .lovable.app link ever expires: not stated in the docs. Replit-style "free apps go down after N days" rules are common, but Lovable's docs don't spell one out — don't assume permanence for anything mission-critical. [unclear] (docs silent — checked 2026-06-07)

If it doesn't work

  • Recipient sees an old version of the app → publishing deploys a snapshot; your later edits stay in the preview until you click Publish → Update. Re-publish to push them. If it's still stale, it's browser cache — hard-refresh. [confirmed]
  • "My change is in the editor but not on the live link" → same thing: the preview and the published app are two different states. Publish → Update. [confirmed]
  • Recipient hits a Lovable sign-in wall on a link you thought was open → the app was published Workspace, not Public — only Public skips the login. Re-open Publish and set access to Public. (Workspace mode is Business/Enterprise only anyway.) [confirmed]
  • The Remix button isn't there for people you sent the project to → public remixing is off by default. Enable public remixing in the project's Share settings. [confirmed]
  • "Remix is blocked / greyed out" → the project is connected to Supabase (it has a backend/database). Lovable only lets you remix projects without a backend. Share the live link for using it, or rebuild a backend-free version to hand out. [confirmed]
  • Out of messages / "you've run out of credits" → you hit the 5-a-day / 30-a-month free cap. Credits reset at midnight UTC (they don't accumulate); wait, or upgrade to Pro for 100 a month. [confirmed]
  • Custom domain option won't let you proceed → custom domains are paid-only. On the free plan you keep the .lovable.app link. On Pro, connect it via Project → Settings → Domains (or the Custom domain tab in the Publish modal). [confirmed]

Prefer to do it all by hand?

That's the only path here — Lovable is a web app, so every step is a click you make in the browser (your coding agent isn't the actor for this one):

  1. Build: lovable.dev → type your app into the home-page prompt box → refine in the chat panel → Connect Supabase (project settings → Integrations) if you need data or logins.
  2. Publish: Publish (top-right) → set the address → set access to Public (for no-login) → Publish → copy the .lovable.app URL.
  3. Make it remixable: project Share settings → enable public remixing → recipients hit Remix to copy it (backend-free projects only).
  4. Update later: Publish → Update re-deploys to the same URL.

Watch / read

  • Best written walkthrough: Lovable's own Publish your Lovable project (the Publish modal, the access options, Publish → Update) plus How to publish a web app (the full "describe → build → live URL" arc for non-developers). These are the authoritative, current sources for every button name above. [confirmed]
  • Community video — How to Publish App On Lovable Ai (2026 Guide) — SimplyStep, ~2 min — a short screen tour of the Publish click and the live link. [unclear — YouTube transcripts couldn't be verified from this machine this session; treat the title as the signal and trust the official docs above for exact steps]
  • Community video — Lovable Tutorial: Build & Deploy a Full Stack App with Login + Database — AI Academy, ~9 min — covers the longer arc (chat-build + Supabase backend + publish) if you want to watch the whole flow end to end. [unclear — transcript not verifiable this session; title-level signal only]

Other ways to share

  • You wrote the code yourself and want others to build on it on their own machines? → a GitHub repository hands over every file with version history and a review-before-merge flow — Lovable is for building in Lovable, not handing over a codebase.
  • It's a small single-page tool, not a multi-page app with a backend? → a Claude Artifact opens in any browser with no account and nothing to publish-then-update.
  • You want full control of hosting and your own domain on the free tier? → deploy a website (Vercel, Netlify, Cloudflare) gives a free custom domain and no per-day build cap.

Sources

  • Publish your Lovable project — Lovable Docs (the Publish icon top-right, the publish modal steps, Public vs Workspace access, security scan, snapshot deploy, Publish → Update to push changes) — checked 2026-06-07
  • Pricing — Lovable (Pro $25/mo with 100 monthly credits + custom domains; Business $50/mo; free plan) — checked 2026-06-07
  • Plans and credits — Lovable Docs (free plan = 5 daily credits, max 30/month, reset midnight UTC, no rollover; credits scale with message complexity) — checked 2026-06-07
  • Create an account — Lovable Docs (sign up free with email, Google, GitHub, Apple; first free workspace created automatically) — checked 2026-06-07
  • Supabase integration — Lovable Docs (native Supabase backend: database, auth, file storage; Connect Supabase under project settings → Integrations) — checked 2026-06-07
  • Custom domain — Lovable Docs (custom domains on paid plans only; connect via Project → Settings → Domains or the Publish modal) — checked 2026-06-07
  • FAQ — remixing — Lovable Docs (you can only remix projects that are not connected to Supabase; published URL lets people view the app, not the code) — checked 2026-06-07
  • How to publish a web app — Lovable (official non-developer guide: describe in chat → build → live URL) — checked 2026-06-07