Skip to content
Lovable

Your Lovable or Bolt App Works in the Demo. Here's What Breaks When Real Users Arrive

Your Lovable or Bolt app worked in the demo — then real users arrived. The five failures that break AI-built apps first, and the checks that catch them.

By Lynxwell Digital November 7, 2026 12 min read
Your Lovable or Bolt App Works in the Demo. Here's What Breaks When Real Users Arrive

The first thing that breaks when a Lovable or Bolt app meets real users is almost never the screens — it's the database permissions. Your app worked in the demo because you were the only user, on test data, with the builder's safety net underneath; production removes all three at once, and the failures show up in a predictable order: open database tables, leaked secret keys, logins that only work in the preview, payments that never actually record, and free-tier ceilings that switch your app off.

This is the deeper companion to our Lovable App Production Checklist — that post is the list; this one is what each item looks like when it fails, and how to check it yourself.

The November 2026 wake-up call: 24,664 apps were readable by anyone

On November 2, 2026, the German security firm Crissy Field and the business daily Handelsblatt published a scan of 159,041 Lovable projects. Of the roughly 34,500 using Supabase, 24,664 returned database records with no authentication at all — plain read requests, the same kind the app itself makes. The haul wasn't trivial: more than 200,000 private chat messages, 80,000 user profiles, over 1,000 passport records, and one CRM-style project that exposed more than 280,000 customer emails and support tickets.

Nobody hacked Lovable — its servers were never breached. Every one of those apps leaked because of a setting in its own database that was never switched on: Row-Level Security. It wasn't the first warning: in March 2025, researcher Matt Palmer found the same misconfiguration across more than 170 Lovable apps (CVE-2025-48757, rated critical at 9.3 out of 10).

Supabase has since tightened the defaults — from May 30, 2026, new projects no longer auto-expose new tables, and the change reached existing projects on October 30, 2026 — but that only protects tables created after the change. If your app predates it, assume nothing is protected until you've checked.

Why the demo works and production doesn't

A preview and a production deployment are different machines running different configuration, and the builder only ever showed you the first one.

In the preview, you're the only user, on test keys, with auth redirects pointing at the preview URL. The builder knows your Supabase project, handles your API keys, and proxies requests through its own servers — quietly sidestepping CORS and connection problems production hits on day one. Real users break all of that within hours: they log out, share links, open two tabs, use a declined card, and paste text nobody anticipated. A developer who went through 264 public reports of Lovable apps breaking — 195 of them Reddit threads — found the biggest groups were logins and database connections (37), Lovable itself being down (33), apps that couldn't be found on Google (32), and data exposed or at risk (31). That last group is the one a working app hides completely: nothing crashes, nobody complains, and the leak runs silently.

What breaks first: the five failures, in order

1. Your database is public

Most Lovable and Bolt apps store data in Supabase, a hosted Postgres database. The browser talks to Supabase directly using a public anon key — that key is meant to be public and ships in every app's frontend. The only thing standing between that key and your data is Row-Level Security: rules inside the database that say which user can see which rows.

Tables created in Supabase's dashboard get RLS switched on by default. Tables created with SQL — which is how migrations and most AI-generated code create them — start with RLS off. A table without RLS answers anyone who asks, login screen or not.

The five-minute test: create two test accounts, add data as A, sign in as B, and try to reach it — including by pasting A's page address into B's browser. If B can see it, you have a permissions problem. Supabase's Security Advisor flags every table with RLS disabled as an error, and enabling RLS with no policies attached is safe: the table returns zero rows until you write one.

2. Secret keys shipped in the browser bundle

A browser app cannot keep a secret. Anything compiled into the JavaScript bundle belongs to whoever opens view-source — and generated apps routinely put keys there.

The rule is simple: anything starting with VITE_ or NEXT_PUBLIC_ ends up in the bundle, readable by anyone. That's fine for a Supabase anon key or a Stripe publishable key. It is a breach for a Supabase service_role key (which bypasses every RLS rule), a Stripe secret key, or an OpenAI key — and the November 2026 scan found service keys and payment records among the exposed data.

The check: search your codebase for service_role, sk_live, and sk-proj. If any appear in frontend code or a VITE_/NEXT_PUBLIC_ variable, rotate the key immediately — assume it's already been read — and move the operation to server code.

3. Sign-in works in the preview and nowhere else

OAuth providers and magic-link emails only redirect to URLs on an allowlist. The preview domain got added automatically while you built; your production domain often did not — which produces the maddening symptom where you, still holding a session from the build, get in fine, while every new user bounces off Google sign-in or clicks a magic link that dead-ends. The fix: set the Site URL in your auth provider (Supabase Auth → URL Configuration) to the production domain, add the production domain and its www variant to the redirect allowlist, register the production callback URL with each OAuth provider, and publish their consent screens instead of leaving them in testing mode.

4. Payments charge the card but never record the order

The checkout page saying "success" proves the payment provider took the money. It does not prove your app recorded it — that record has to come from the provider's webhook: delivered to your endpoint, signature verified, matched to the right user, written exactly once even when the webhook retries.

Generated integrations tend to treat the browser redirect as the source of truth and skip the webhook path entirely — which is how a customer pays and has nothing to show for it. Test it before you take a real payment: complete a test purchase, then check whether the order exists in your database without ever visiting the success page. If it doesn't, your payment flow is a demo, not a store.

5. The free-tier ceilings that switch you off

This is the failure that looks like an outage but is actually a bill. The free tiers underneath most AI-built apps have hard ceilings, and what happens at the ceiling runs from "slow" to "your site is gone":

PlatformThe ceilingWhat happens when you hit it
Supabase Free500 MB databaseDatabase goes read-only — new sign-ups and orders fail
Supabase Realtime Free200 concurrent connectionsNew connections refused; live features silently stop updating
Netlify Free300 credits a monthEvery site on the team is paused with a "Site not available" page until next month
Bolt.new100 MB total project sizePublishing fails outright: "project is too large to deploy"
Bolt Cloud databaseInactivityDatabase pauses after a period of inactivity; first visitor waits for it to wake

The Netlify one is the harshest: credits belong to the team, so one project going viral takes every site on the account offline, with no way to buy more credits on the free plan. Supabase's storage ceiling doesn't reset monthly either — the fix is deleting data or upgrading, not waiting.

What practitioners keep running into

Three things from the people actually fixing these apps, not the docs:

Check the status page before you spend credits. When a published site goes down, Lovable's own hosting docs say to check status.lovable.dev first — it tracks published sites separately from the editor. The analysis of those 264 public reports found at least four cases where people burned Lovable credits on prompts and builds that failed because Lovable itself was having problems; in the same 90-day window the status page listed 36 incidents. And remember your published site is a snapshot, not your working copy: edits aren't live until you open the Publish dialog and click Publish changes — a small dot on the Publish button means you have unpublished changes — and publishing costs no credits, even at a zero balance.

The built-in security scan is a start, not a verdict. Lovable now scans database access rules when the publish dialog opens — but it checks whether RLS is switched on, and switched on is not the same as switched on correctly. A table can have RLS enabled with a policy that says, in effect, allow everyone, and still pass. The test that matters is still the two-account test above.

What we'd do

At Lynxwell Digital, this is the work that lands on our desk most often now — founders bring us Lovable, Bolt, or v0 apps that looked finished in the demo and started failing the week real users arrived. Here's the order we'd work through it in:

  1. Stop the bleeding first. Enable RLS on every table, rotate any key that ever appeared in frontend code, and run the two-account test. This is an afternoon's work.
  2. Then fix the seams. Auth redirect URLs, the payment webhook path, and environment variables on the production host — the three places where "works in preview" most often turns into "broken live."
  3. Then decide: harden or rebuild. If the app is small and the gaps are the five above, hardening is days of work, not a rebuild. If the data model itself is wrong — no audit trail, no way to roll back — that's when rebuilding the backend starts to make sense, and we'd say so before taking the job.
  4. Finally, put it on real rails. Code in a GitHub repo you own, a staging copy with its own database, and error tracking that tells you when something breaks instead of a customer telling you.

If your app is in that in-between state — built, demoed, not yet safe for strangers — our free rescue audit is built for exactly this: we run the checks above against your live app and tell you what's actually broken, in what order, before anyone's data or money is at stake. We also wrote about the subscription portal we built on top of Recharge's API when a client's customers couldn't edit their subscriptions — same pattern, different symptom.

FAQ

Can a Lovable app be used in production?

Often, yes — once the basics are in place. The app itself is real code. What decides it isn't the builder, it's whether someone closed the five gaps above: database permissions, secret keys, auth redirects, payment webhooks, and free-tier ceilings.

How do I check if my Lovable app's database is exposed?

Open your Supabase dashboard and go to Advisors → Security: it flags every table with Row-Level Security disabled. Then do the two-account test — create two accounts, add data as one, try to read it as the other. If the second account can see the first account's data, your tables are exposed: enable RLS on every table and write a policy per table before your next user signs up.

Why does my Lovable app work in preview but break after publishing?

Preview and production are different environments. The preview runs through the builder's own servers with test keys and the preview domain already allowlisted for auth. Production connects directly, needs its own environment variables on the host, and needs the production domain added to your auth provider's Site URL and redirect allowlist. The most common single cause is an environment variable that exists in the builder but was never added to the production host — and frontend frameworks bake those variables in at build time, so changing one means redeploying.

What is the most common Lovable production failure?

An open database. A November 2026 scan of 159,041 Lovable projects found that of the roughly 34,500 using Supabase, 24,664 returned database records with no authentication — because Row-Level Security was never switched on. It's the most common failure and the most dangerous, because the app works perfectly while its data is readable by anyone.

Should I rebuild my Lovable app or harden it?

Harden it first, unless the data model itself is wrong. Most production failures are configuration, not architecture: RLS off, keys in the bundle, auth redirects pointing at the preview, payments confirmed in the browser instead of by webhook. Those are days of fixes. Rebuild when the app can't do what the business needs — no audit trail, no rollback, no way to separate staging from production data — and even then, rebuild the backend first and keep the screens that work.

The bottom line

A Lovable or Bolt app that works in the demo has proved one thing: the idea is buildable. Production proves something else — that strangers' data stays theirs, that money lands in the right place, and that the app stays up when nobody's watching. The gap between the two is usually five fixes, not a rewrite. Run the checks above before your next user signs up, not after.

And if you'd rather have someone else run them: send us your app's URL through our free rescue audit. We'll tell you straight what's broken, what order to fix it in, and whether hardening or a rebuild is the honest answer.

Built your app with Lovable, Bolt or Replit and it’s acting up with real users? Our Launch Safety Audit is $390, and free if we find nothing critical: lynxwelldigital.com/lp/fix-ai-app

#Lovable#Bolt#vibe coding#production
All posts

Shipped fast, broke in production?

That is the job we do most. Send the repo and a senior engineer records a 20-minute teardown: what is broken, how bad it is, and what it would cost to fix. Free, and the findings are yours either way.

First call's free
5.0 · usually replies in ~2 hours
  • Real human replies in ~2 hours
  • Fixed price, agreed before you pay
  • No lock-in, you own everything
  • Free first call + honest audit