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

- Author: Olger Chotza
- Published: 2026-11-17
- Tags: llm, security, design
- Canonical: https://ochotzas.com/notes/production-is-the-part-you-cant-click-on

export const exposedSquares = [3, 17, 22, 38, 41, 59, 64, 76, 85, 97];

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.

:::note[What this is based on]
I didn't build and audit an app for this. It rests on two public disclosures, the text of the GDPR, and what a SOC 2 audit is. Each claim links to its source.
:::

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

<figure class="diagram">
  <div class="plate waterline">
    <div class="layer layer-head"><span>Part of the app</span><span>How you find out it's wrong</span></div>
    <div class="layer layer-seen"><span>Screens</span><span>You look at them</span></div>
    <div class="layer layer-seen"><span>Forms</span><span>You type in them</span></div>
    <div class="layer layer-seen"><span>Login</span><span>You log in</span></div>
    <div class="layer layer-seen"><span>Checkout</span><span>You pay with a test card</span></div>
    <div class="waterline-mark">The preview stops here</div>
    <div class="layer layer-unseen"><span>Who can read which rows</span><span>A stranger reads them</span></div>
    <div class="layer layer-unseen"><span>Secret keys in the browser</span><span>Someone opens DevTools</span></div>
    <div class="layer layer-unseen"><span>Rate limits</span><span>A bot finds your signup form</span></div>
    <div class="layer layer-unseen"><span>Backups</span><span>The day you need one</span></div>
    <div class="layer layer-unseen"><span>Database migrations</span><span>A deploy drops a column</span></div>
    <div class="layer layer-unseen"><span>Logs and alerts</span><span>A customer emails you</span></div>
    <div class="layer layer-unseen"><span>Deleting someone's data</span><span>A regulator asks</span></div>
    <div class="layer layer-unseen"><span>Someone on call</span><span>3am</span></div>
  </div>
  <figcaption>Above the line, you find out in seconds and the tool fixes it. Below it, someone else finds out first.</figcaption>
</figure>

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.

<figure class="diagram">
  <div class="plate">
    <div class="waffle" role="img" aria-label="100 squares, 10 of them dark: about one app in ten was exposed.">
      {Array.from({ length: 100 }, (_, square) => <span class={exposedSquares.includes(square) ? "waffle-hit" : undefined} />)}
    </div>
    <div class="legend"><span class="legend-item"><span class="swatch swatch-write"></span>Data readable or writable by anyone: 170 apps</span><span class="legend-item"><span class="swatch swatch-mark"></span>Locked down</span></div>
  </div>
  <figcaption>Each square is about 16 of the 1,645 apps scanned. The exposure covered 303 endpoints and became <a href="https://nvd.nist.gov/vuln/detail/CVE-2025-48757">CVE-2025-48757</a>.</figcaption>
</figure>

The exposed data was [reported to include](https://www.superblocks.com/blog/lovable-vulnerabilities) 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](https://www.wiz.io/blog/critical-vulnerability-base44) 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:

```sql
alter table invoices enable row level security;

create policy "owners read their own invoices"
  on invoices for select
  using (auth.uid() = user_id);
```

```bash
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.
