Lovable can turn an idea into a working app in an afternoon. Then the same few problems show up, again and again, in r/lovable, in founder groups and in the projects people send me. The good news is that most of them have boring, reliable fixes.
These are the issues I see most often, roughly in the order they cause pain.
1. The fix loop that eats your credits
What it looks like: you ask Lovable to fix an error. It fixes it and breaks something else. You ask it to fix that, and the first error comes back. Twenty credits later you’re further from a working app than when you started.
This is the most common complaint by a distance. As a project grows, the agent loses track of how the pieces depend on each other, so each “fix” is a guess.
How to get out of it:
- Use “Try to fix” first. Lovable’s own FAQ says that button doesn’t use credits. Typing “fix the error” into chat does.
- Stop after two failed attempts. If the agent hasn’t fixed it in two tries, a third won’t help. Restore the last working version from the history and change your approach.
- Ask it to explain before it edits. Something like “Don’t change any code yet. Explain what causes this error and which files are involved.” A diagnosis is cheaper than a wrong fix, and it often shows you the real cause.
- One change per prompt. “Add Stripe, fix the navbar and make the dashboard faster” gives the agent three chances to break things at once.
- Use Plan mode for anything risky, so you can see which files it intends to touch before it touches them.
If an app keeps falling back into loops, it’s usually because something underneath is wrong, often the database or the auth setup. More prompting won’t fix that. Someone needs to read the code.
2. Your database is readable by anyone
What it looks like: nothing. That’s the problem. The app works perfectly, and any visitor who opens the browser dev tools can read every user’s data.
Lovable apps talk to Supabase (or Lovable Cloud, which is built on it) straight from the browser using a public key. That’s by design, but only if row-level security (RLS) is on and every table has a policy saying who can see what. When RLS is off, the public key opens the whole table.
This isn’t theoretical. In 2025 a researcher scanned 1,645 Lovable apps and found 170 with exposed databases. That became CVE-2025-48757. Independent audits through 2026 keep finding the same pattern.
How to fix it:
-
Run the built-in scan. Open your project, go to More → Security, and run the scan. A basic scan also runs automatically when you publish. Fix everything it flags.
-
Don’t stop there. The scan checks whether policies exist. It can’t tell you whether they’re right. The most common mistake is a policy that only checks the user is signed in, which lets every signed-in user see every row. Policies should compare the row’s owner with the current user:
alter table public.notes enable row level security; create policy "Users read their own notes" on public.notes for select to authenticated using ((select auth.uid()) = user_id); create policy "Users add their own notes" on public.notes for insert to authenticated with check ((select auth.uid()) = user_id);Add matching
updateanddeletepolicies the same way. -
Test it like an attacker would. Signed out, ask the API for the table directly with your public anon key:
curl "https://YOUR-PROJECT.supabase.co/rest/v1/notes?select=*" \ -H "apikey: YOUR_ANON_KEY"If that returns real rows, the table is open.
-
Check for the service role key in the frontend. Search the code for
service_role. That key bypasses RLS completely and must only live on the server. If it was ever shipped to the browser, rotate it. -
Check your storage buckets too. Uploaded files (avatars, invoices, ID photos) have their own access rules, separate from the tables.
One more: in April 2026 Lovable disclosed that chat history and code in public projects had been viewable by other Lovable users since February. It’s fixed, and Lovable made existing public projects private. If you’d ever pasted a key into the chat of a public project, rotate it anyway.
3. Login emails send people to localhost
What it looks like: sign-up works, the confirmation email arrives, and clicking the link opens localhost:3000 or a blank page. Password reset and Google sign-in break the same way.
Why: Supabase builds those links from its Site URL setting, and that still points at localhost or at your old preview address.
How to fix it: in the Supabase dashboard (through the Cloud tab on Lovable Cloud), open Authentication → URL Configuration:
- Set Site URL to your live domain, e.g.
https://yourapp.com, with no trailing slash. - Under Redirect URLs, add every address the app runs on:
https://yourapp.com/**, your*.lovable.appaddress, and any Vercel or Netlify domain. - For Google or GitHub sign-in, the provider’s own console also needs Supabase’s callback URL on its allowed list.
Then test the whole flow with a brand-new email address. Don’t trust an account you created months ago.
4. Works in preview, blank white screen after deploying
What it looks like: you connect GitHub, deploy to Vercel or Netlify, and get an empty white page. The browser console says something like VITE_SUPABASE_URL is undefined.
Why: the keys your app needs live in Lovable. They don’t travel with the code to GitHub or to another host.
How to fix it: copy each public variable (they start with VITE_ on older projects) into your host’s environment settings, then redeploy. Changing an environment variable doesn’t update a build that already exists. Server secrets like your Stripe secret key never go in VITE_ variables, because everything with that prefix ends up in the browser.
5. Every page except the homepage gives a 404
What it looks like: clicking around works, but refreshing /dashboard or opening a shared link to it gives a 404.
Why: projects built before mid-2026 are single-page apps. There’s one real HTML file, and the app’s router handles everything else in the browser. Lovable’s own hosting knows this. Vercel and Netlify don’t until you tell them.
How to fix it: for Vercel, add a vercel.json at the project root:
{
"rewrites": [{ "source": "/(.*)", "destination": "/index.html" }]
}
For Netlify, add a file called _redirects (no extension) in public/:
/* /index.html 200
Commit, then redeploy. Newer TanStack Start projects (see the next section) don’t need this, but they do need a host that can run their server, not just serve static files.
6. Google can’t see your site
What it looks like: the site has been live for weeks, but it isn’t on Google, and link previews in WhatsApp or LinkedIn show the wrong title.
Why: older Lovable apps render in the browser. A crawler that doesn’t run JavaScript gets an almost empty page.
What changed: since 13 May 2026, new Lovable projects are built on TanStack Start with server-side rendering, so crawlers get real HTML. Older projects hosted on Lovable get pre-rendered snapshots for crawlers. Older projects hosted somewhere else get neither.
How to fix it:
- Check which stack you’re on. If project settings shows a Migrate option, you’re on the old one. Run
/migrateor ask the agent to “upgrade my app to TanStack” to get server rendering without a rebuild. Duplicate the project or make sure GitHub is connected first, so you have a way back. - Give every page its own title and description, not just the homepage.
- Add a sitemap, verify the domain in Google Search Console and submit it there.
- Paste a URL into Search Console’s URL Inspection tool and look at the rendered screenshot. If it’s blank, Google sees a blank page.
7. Your changes vanish
What it looks like: you fix something by hand, or a developer pushes a change, and a day later it’s gone.
Why: Lovable’s GitHub sync works both ways, on one branch. If the same file changes in Lovable and in GitHub at about the same time, one version wins and the other disappears. The agent can also rewrite a hand-edited file when it works on a nearby feature.
How to fix it:
- Edit in one place at a time. If you change code on GitHub, wait for it to show up in Lovable before you prompt again.
- Don’t rename, move or force-push the synced repo. Renaming can break the connection entirely.
- Once a real developer is working on the code, decide which files Lovable may still touch and say so in the project’s knowledge or rules. Or stop using the agent on that project altogether.
- If something does go missing, look in Lovable’s version history first, then in the GitHub commit log. It’s almost always in one of the two.
8. Payments go through but the app doesn’t know
What it looks like: Stripe shows a successful payment, but the user is still on the free plan.
Why: your app learns about payments from Stripe webhooks. If the webhook URL isn’t registered in Stripe, the signing secret is wrong, or the handler skips signature checks and then falls over, the database never updates. Nothing tells you.
How to fix it:
- In Stripe, go to Developers → Webhooks and confirm the endpoint points at your deployed handler, not the preview.
- Put the webhook signing secret (
whsec_…) in Lovable’s secrets. Never put it in the code. - Make sure the handler verifies the signature. Without that, anyone can tell your app a payment happened.
- Use Stripe’s event log. Failed deliveries show the exact error your handler returned.
- Test a full purchase in test mode on the live site, then cancel it, and check that the database follows both events.
When to stop prompting
Lovable is genuinely good at the first 80%: screens, flows, a working demo you can show investors or early users. The last 20% is security, payments, auth edge cases and deployment, and that’s where a prompt-only approach starts costing more than it saves.
A quick rule of thumb: if you’ve spent more than a day, or more than a month’s subscription in credits, on one bug, stop. Have someone read the code.
If that’s where you are, I fix Lovable apps for founders. See how I rescue Lovable projects or get in touch. Most rescues take days, not a rewrite.