Explain My BuildHow to document your Lovable app
Last updated: July 26, 2026
To document a Lovable app, connect its GitHub repo or exported code to Explain My Build. It reads the real React/Vite front end and Supabase back end Lovable generated and writes an end-user guide, a founder runbook and a code-verified fix-list. You own the code, so nothing is proprietary or locked.
What is a Lovable app, and where does its code live?
A Lovable app is a full-stack web app that Lovable's AI generated from your prompts. Under the hood it is standard, ownable code — not a proprietary format — which is exactly why it can be read and documented.
- Front end: React with TypeScript, built with Vite, styled with Tailwind CSS, using shadcn/ui components. This is conventional, readable code, not a black box.
- Back end: Supabase by default — Postgres database, auth, storage and Edge Functions — either as your own Supabase project or via Lovable Cloud, a managed Supabase instance Lovable runs for you.
- Where the code lives: Lovable offers bidirectional GitHub sync (changes flow both ways) and a ZIP export. Because Lovable emits real React/TypeScript you fully own, you can push it to GitHub and keep editing in any IDE.
Explain My Build reads that repo or export directly. It maps your pages, forms, Supabase tables, auth flow and any Edge Functions from the actual files — the same code Lovable wrote.
Before and after: a raw Lovable project becomes a user guide
Here's the difference reading code makes. On the left is what you have after building in Lovable; on the right is an excerpt of the end-user guide Explain My Build writes from it.
| Raw Lovable project (what you have) | End-user guide excerpt (what your users get) |
|---|---|
A src/pages/Dashboard.tsx route, a Supabase projects table with a row-level security policy, and a ClientInvite.tsx component you don't remember prompting. | "Inviting a client: Open your dashboard and select Invite client. Enter their email and they'll receive a link. Each client can only see the projects you've shared — your other clients' data stays private." |
Notice the guide describes the invite feature and the privacy behavior — both read straight from the code and its Supabase row-level security policy. A screen recording would only capture the invite feature if you happened to click it, and couldn't see the security rule at all.
What will your Lovable users ask? A checklist
Your Lovable app's end-user guide should answer the questions real users type. Explain My Build derives these directly from the routes and features in your code:
- How do I sign up and log in? (from your Supabase auth flow)
- How do I do the main thing the app is for? (from your primary route)
- How do I invite or share with someone else? (from any invite/sharing components)
- Can other people see my data? (from your row-level security policies)
- How do I upload a file or image? (from Supabase storage usage)
- How do I change my settings or delete my account? (from your settings routes)
- What happens when something goes wrong / I hit an error? (from error handling in the code)
Because the guide is written from code, it won't invent a feature you don't have — and it won't miss one you forgot you shipped.
What three artifacts do you get for a Lovable app?
From one read of your Lovable code you get three outputs:
- End-user guide — plain-English help for the people who use your app, with a share link and access code, an in-app Help widget, and a portable export. $19/month ($12/month founding for the first 100).
- Founder runbook — how to run, deploy and extend your Lovable app: what each Supabase table is for, which Edge Functions exist, and how the pieces connect. Free.
- Code-verified fix-list — ranked issues cited to code, ready to paste back into Lovable or another AI. A common find: a Supabase table with row-level security left off, or an API key committed to the repo. Free.
Worried about that last point? Read is my Lovable app secure? for what the code read checks.
An honest note on Lovable Edge Functions
Lovable can't natively deploy or test Supabase Edge Functions inside its own web IDE, so some server-side logic may live only in your Supabase project. Explain My Build reads the code it can see in your repo; if server-side logic or secrets live only in a Supabase dashboard we never receive, we flag that gap rather than guess what's there. And you review the end-user guide before publishing.
Frequently asked questions
How do I create a user guide for my Lovable app?
Connect your Lovable app's GitHub repo (Lovable syncs bidirectionally) or its ZIP export to Explain My Build. It reads the React and Supabase code Lovable generated and writes an end-user guide in plain English, cited to your actual routes and features. You review and edit it before publishing.
Does Explain My Build work with Lovable Cloud or only my own Supabase?
It works from your code, so it reads the React front end and any Supabase logic present in your repo either way. If your backend is on Lovable Cloud (a managed Supabase instance) and some server-side logic or secrets never reach the repo, we flag that gap rather than guessing what's on the managed side.
Can I document a Lovable app without exporting to GitHub?
Yes. You can use Lovable's ZIP export and run it as a local folder entirely in your browser, so the code never leaves your machine. GitHub sync is the most convenient path, but it isn't required.
Is my Lovable code proprietary or locked to the platform?
No. Lovable emits standard React and TypeScript you fully own and can continue editing in any IDE. That's precisely why it can be read and documented — there's no proprietary abstraction to reverse-engineer.
Turn your app into a guide your users can follow.
Paste a public GitHub link and get your founder runbook + fix-list free in about a minute — no sign-up. Private code runs entirely in your browser.