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.
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:
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.
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.