Olger Chotza
  • llm
  • security
  • design

Production Is The Part You Can't Click On

Lovable, Bolt, v0 and Base44 build what you can see in a preview. Security and compliance live where the preview can't look, and the tool can only check what you can.

7 min read

You type a paragraph, and four minutes later there is a SaaS app on a URL. It has a login page, a dashboard, a pricing table and a working checkout. You click through it and everything works.

Then someone calls it production-ready, and that’s where it goes wrong.

The tools aren’t bad. Lovable, Bolt, v0 and Base44 are good at exactly what they promise. The trouble is that “it works when I click on it” and “it’s safe to put customers’ data in” are checked in completely different ways. The tool can only check the first one.

The preview is the whole feedback loop

These tools learn whether they got it right from you, looking at a preview. A screen that renders wrong gets a follow-up prompt. A button that does nothing gets a follow-up prompt. Everything you can see gets fixed fast.

Now look at how much of a production SaaS app you can actually see:

Part of the appHow you find out it’s wrong
ScreensYou look at them
FormsYou type in them
LoginYou log in
CheckoutYou pay with a test card
The preview stops here
Who can read which rowsA stranger reads them
Secret keys in the browserSomeone opens DevTools
Rate limitsA bot finds your signup form
BackupsThe day you need one
Database migrationsA deploy drops a column
Logs and alertsA customer emails you
Deleting someone’s dataA regulator asks
Someone on call3am
Above the line, you find out in seconds and the tool fixes it. Below it, someone else finds out first.

It’s worse than the second row just going unchecked. From the preview’s point of view, every security control is a feature that makes things fail. An access rule denies a request. A rate limit rejects one. A missing policy, on the other hand, makes the app work better in the preview, because nothing ever says no.

A loop that fixes whatever you complain about will never, on its own, add the thing whose only visible effect is a refusal.

What that looks like in public

Lovable: the rule nobody saw missing

Lovable apps typically sit on Supabase. Supabase gives the browser a public key on purpose. The key is meant to be seen, and what protects the data is row-level security (RLS): rules in the database that decide which rows each user can read or write. Without them, the public key reads everything.

In March 2025 a researcher scanned 1,645 Lovable-built apps for exactly that.

Data readable or writable by anyone: 170 appsLocked down
Each square is about 16 of the 1,645 apps scanned. The exposure covered 303 endpoints and became CVE-2025-48757.

The exposed data was reported to include home addresses, API keys and personal financial details. Each of those 170 apps worked perfectly in its preview, and nothing on screen showed a problem.

Lovable’s position was that configuring RLS is the app owner’s responsibility. That is technically true, and it’s the whole point of this note. The person told the work was done is the same person who couldn’t see the missing rule.

Base44: the platform’s own hole

In July 2025, Wiz found two undocumented Base44 endpoints, for registering and for verifying a one-time code, that needed no authentication. Anyone with a private app’s ID, which sits in its URL, could create a verified account on it, straight past the single sign-on that was supposed to keep outsiders out.

Base44 deserves credit here: it was fixed within 24 hours of disclosure, for every app at once, and no owner had to do anything.

Put the two side by side and the real problem shows:

Base44 Lovable
Whose bug The platform’s Each app’s
Who fixed it The platform, once Every owner, separately
Time to fix Under a day However long until the owner finds out
Visible in the preview No No

The platform can fix its own bugs for everyone at once. It can’t fix yours, and it can’t tell you that you have one.

Compliance isn’t a file in the repo

“Compliant” is the word that gets stretched furthest. It sounds like a property of code, but it’s mostly about the organisation behind the code.

SOC 2 is an independent auditor’s report on whether a company’s controls actually operated over a period, usually months. They’re checking access reviews, onboarding and offboarding, change management and incident response. You can’t generate any of that from a prompt, because it’s evidence that people did things over time.

GDPR has some code in it, but most of it is commitments:

What GDPR asks for Code can help with Still needs a person
Erase someone’s data on request (Art. 17) A delete that reaches every table, backup and third party Someone to receive the request and answer it in time
Contracts with every processor (Art. 28) Nothing Signed agreements with the database host, email provider, analytics
A record of what you process (Art. 30) Nothing A maintained document
Report a breach within 72 hours (Art. 33) Logs that show a breach happened Someone who reads them, and a plan

A generated app can have a delete-account button. It can’t have a data processing agreement with Supabase, and it can’t notice a breach on a Sunday.

So what are these tools for

They’re very good at the part of a product that used to be the expensive gamble: finding out whether anyone wants it. A clickable app in an afternoon, in front of real people by evening. That used to take a sprint.

Use them for that, and for internal tools that touch no one’s personal data. Then, before real customers or real data arrive, treat the generated app as a very good spec. Rebuild or review the second row of the diagram on purpose, because nothing will make you notice it otherwise.

Already shipped one?

If there are real users on it today, this is the short list, in order:

  • Turn on RLS for every table, and write a policy for each one
  • Query every table with only the public key, logged out, and expect nothing back
  • Search the built JavaScript for anything secret: service keys, Stripe secret keys, third-party API keys
  • Check that every server function verifies who is calling, not only that someone is logged in
  • Confirm backups exist, then restore one somewhere to prove it
  • List every service that touches personal data, and sign their data processing agreements
  • Decide who reads the alerts, and make sure alerts exist

For Supabase, the first two look like this:

alter table invoices enable row level security;

create policy "owners read their own invoices"
  on invoices for select
  using (auth.uid() = user_id);
curl "https://<project>.supabase.co/rest/v1/invoices?select=*" \
  -H "apikey: <public anon key>"

With RLS on, that curl returns []. If it returns rows, so would anyone else’s.

Olger Chotza

Useful? Wrong? Both? I'd like to hear which.

Say Hello

Keep Reading

  • The Cache Miss You Pay For Every Turn