📑 Table of contents

Lovable: 159,000 projects scanned, 24,664 Supabase databases open without auth — passports and 200,000 chats exposed

No-Code IA 🟢 Beginner ⏱️ 17 min read 📅 2026-11-16

Lovable: 159,000 Scanned Projects, 24,664 Supabase Databases Open Without Auth — Passports and 200,000 Chats Exposed

🔎 The Biggest Leak in Vibe Coding — And No One Had to Force the Door

On November 2, 2026, the German firm Crissy Field GmbH published, in parallel with the reference investigation by Handelsblatt, the results of a massive scan of applications created with Lovable. The figure summarizes everything: out of 159,041 identified projects, 24,664 returned records from their database as soon as the page loaded. No login. No account. Nothing.

Lovable, for its part, lacks neither means nor ambition. Founded in Stockholm in 2023 by Anton Osika and Fabian Hedin, the company closed a $400M round in August 2026, valuing it at $13.3B. It claims over 50 million projects created and 1.2 million new projects per week — for a clientele that, for the most part, does not know how to code.

The most disturbing part is captured in one sentence from the report: it is not a matter of intrusion, but of data "behind an unlocked door." The code generator produced the same poorly closed door tens of thousands of times, in a row. That is the entire lesson of this study — and it extends far beyond Lovable.


The Essentials

  • 159,041 Lovable projects identified via Common Crawl between December 2025 and September 2026. 34,545 used Supabase as a backend.
  • 24,664 sites returned records upon loading, without authentication—representing approximately 71% of projects built on Supabase.
  • Emails were found in 10,560 exposed tables across 7,403 sites, accounting for 30% of the sites that were leaked.
  • Documented cases: a German lifestyle forum with 80,000+ complete profiles and 200,000+ chat messages, a provider exposing 1,000+ records with passport numbers, expiration dates, and nationalities, 280,000 accessible emails, contracts, invoices, photo albums, and internal WhatsApp communications.
  • No platform hacking: the root cause, recognized by Lovable, is missing or improperly configured Row Level Security (RLS) within the applications themselves.
  • Supabase's Security Advisor only detects disabled RLS—a policy using (true) passes the check while allowing anyone to read everything.
  • The lesson applies to all code-gen: uniform scaffolding replicates the same vulnerability on an industrial scale, regardless of the model used.

No need for an arsenal to check your exposure: two tools and ten minutes are enough to find out whether your app is one of the affected ones.

Tool / resource Main use Price (November 2026) Ideal for
Lovable Create apps from prompts Free tier available (check lovable.dev) Auditing apps already live, not just building them
Supabase Postgres backend for Lovable projects Free tier available (check supabase.com) Enabling RLS, writing policies, testing with the anon key
UpGuard Attack surface monitoring Quote-based (check upguard.com) Continuously detecting your exposed databases and domains

The study's numbers: a pyramid that says it all

Of 159,041 scanned Lovable projects, 24,664 — roughly 71% of those built on Supabase — exposed their database data as soon as the page loaded, without any authentication whatsoever.

The methodology gives a

Why so many Lovable apps are leaking: code-gen's uniform scaffolding

Because the generator produces the same architecture everywhere — and that architecture places, by design, the database access key in the visitor's browser.

How Supabase works is simple and, taken in isolation, sound. Every project exposes a REST API; the web client embeds a so-called "anon" key, public by design; the only barrier between any visitor and your tables is called Row Level Security, SQL policies that decide who reads what. If the policies exist and are written correctly, the model holds up. If they're missing — or boil down to a using (true) — the anon key in the JavaScript becomes a universal master key.

Yet this is precisely what code-gen produces most readily. A model optimizes for the visible result: the form displays, the click saves, the list updates. The shortest path is to create the table, read it directly with the anon key, and move on to the next screen. The policy, meanwhile, never shows up in any demo. The result: an identical skeleton from one app to the next, with the same flaw, replicated at an industrial pace — 1.2 million new projects per week, according to figures claimed by Lovable.

The audience makes everything worse. The majority of Lovable users can't program: they can't audit what they can't read, and nothing in the interface tells them the door is wide open. They see an app that works. This is the flip side of the no-code promise — the one about creating a chatbot or a complete app without writing a single line of code: the tool that does everything also mechanically produces every flaw.

An important detail: the model changes nothing. Whether your app is generated with GPT-5.5, Claude Opus 4.7 (Adaptive) or Gemini 3.1 Pro — or even with a free model via OpenRouter or Groq — the failure isn't in the quality of a function, it's in the architecture produced. Our comparison of the best LLMs for coding as well as our guide to using free models without sacrificing quality don't exempt you from the test that follows, for that matter: it's a skeleton problem, not a gray-matter problem.

Finally, the flaw isn't specific to Lovable. Integrated code assistants — Cursor, Copilot, Cline, all reviewed in our comparison of the best AI tools for code — generate the same type of Supabase integration, with the same shortcuts. Uniform scaffolding is a property of the ecosystem, not of a single platform.


RLS enabled doesn't mean secure: the using (true) trap

The worst part of this affair is that many app publishers genuinely believed they had done what was needed — and saw a green security indicator.

Supabase includes a Security Advisor, a linter that reviews projects. The problem, documented in post-study analyses: it only flags disabled RLS, not what the policies allow (details on dev.to). A USING (true) policy — literally "this rule applies to everyone, always" — enables RLS in appearance, checks the box, reassures the dashboard… and lets anyone holding the public key read every row of every table. Yet this public key is, by design, in the app's JavaScript. The check passes, the leak remains.

A second mechanism noted in the study discussion on Hacker News: schema leakage via the hint field of PostgREST error messages. A malformed query returns a message that reveals table and column names. Concretely, anyone can map your database without documentation, without an account, without effort — and then know exactly what to query.

The combination of the two explains the scale of the figure: tables that are easy to discover, a public access key, and a security indicator that says "all is well" precisely where the problem lurks.


The ten-minute test to run on your app today

Two requests are all it takes to know whether your database is wide open — and Lovable itself has validated this diagnosis.

Through its head of security, the company acknowledged that the root cause in these applications was insufficient RLS. The community turned this into a protocol that any app builder can run right away (detailed protocol on dev.to).

Test 1 — the anon key. Grab the public anon key from your app's JavaScript or from the Supabase settings, then use it to query your tables while logged out:

curl "https://VOTRE-PROJET.supabase.co/rest/v1/votre_table?select=*" \
  -H "apikey: VOTRE_CLE_ANON" \
  -H "Authorization: Bearer VOTRE_CLE_ANON"

If the response contains data rows while you're not authenticated, your app is among the 24,664.

Test 2 — another user's token. Log in with test account A, grab its token, then try to access the rows created by account B. If you can see them, per-user isolation is broken: one user can read other users' data, which is a leak in the fullest sense of the word.

If either test fails: enable RLS on every table, write explicit policies (typically auth.uid() = user_id on user data tables), ban any using (true) on real data, then run both tests again. And do it before real users show up, not after Handelsblatt comes knocking.


Lovable, Supabase, you: who bears the responsibility?

Technically, the app's publisher. Structurally, the entire code-gen ecosystem — and that's where it gets interesting.

Let's start with what is established. This is not a platform hack: the vulnerabilities stem from missing or misconfigured RLS rules in the apps, not from a flaw at Lovable (Cybernews analysis). The company has acknowledged as much, through its head of security. Crissy Field's phrasing is airtight: no intrusion, just data behind a door left unlocked.

But stopping there would be too comfortable. Lovable sells app creation to people who can't code, with default scaffolding that allows this outcome. Telling a non-technical user "the security of your database comes down to your SQL policies" is less a security model than a disclaimer. A platform generating 1.2 million apps per week could make security policies mandatory at generation time, or block the deployment of a user table without real RLS. This is not an unsolvable technical problem — it's a product choice.

Supabase has its share too: when its Security Advisor gives a green light to a using (true) policy, the oversight tool creates a false sense of security precisely where the trouble lurks.

Finally, the bill lands on the app publisher. Exposing passport numbers or 280,000 emails is no trivial technical incident: it's the processing of unprotected personal data, with everything that implies under GDPR for whoever is responsible. And the cruelest uncertainty remains — no one can say whether this data has already been siphoned off. After months of public exposure, prudence dictates assuming that it has.


Vibe coding without getting hacked: the non-negotiable rules

Security can't be prompted: it has to be configured, tested, and re-tested. Here's what should become second nature for anyone putting an AI-generated app online — all the more so when it plugs into an automation chain like Make, Zapier or n8n, where every additional connection widens the surface to audit.

  1. Test the anon key before every production release. The ten-minute test above, to be replayed on every deployment that touches the database schema.
  2. RLS on every table, explicit policies. No using (true) on user data. If you don't know how to write the policy, don't put the table online.
  3. Always test with two accounts. User A should never see a single row belonging to user B. It's the only test that validates real isolation.
  4. Don't store what you wouldn't want published. Passport numbers in a service-booking app? Ask yourself why that data exists in the database at all. Minimization remains the only defense that works in every case.
  5. Keep a human in charge of permissions. Vibe coding pushes for speed — some people even run their projects from Telegram with AI. Great for product iteration, but no release should go live without a human having reviewed the policies. And if nobody knows how to read them, our analysis No-code vs code: when should you learn to program? explains at what point learning becomes the real shortcut.
  6. If you self-host, master both doors. Hosting your own backend — Supabase can be self-hosted, or a classic Postgres on a VPS — makes the configuration explicit; our guide to the best hosting for AI projects (Hostinger to start small) details the options. And on the network side, approaches like Cloudflare Tunnel let you expose your services without opening ports. But keep in mind that a poorly protected database also leaks through its official API: RLS and network exposure are two distinct problems, to be handled separately.

Grok Build, Lovable: the lesson applies to all code-gen

Lovable is not an isolated accident: it is the biggest illustration to date of a systemic flaw in AI-assisted development.

The precedent already existed. Skynet Watch had documented that 947 of the apps created with Grok Build were accessible without an account — same pattern, different platform. And the independent study relayed by Cybernews broadens the picture: UpGuard examined roughly 300,000 Supabase domains and found 16,326 readable from the outside, more than half of them containing personal data. That figure isn't just about Lovable: it describes the entire "AI-generated app on Supabase" ecosystem — and, beyond that, the whole galaxy of no-code tools hooked up to databases, which we cover in our selection of the best no-code tools for using AI.

Three factors combine to produce this outcome at scale: uniform scaffolding that replicates the same architectural choices, a largely non-technical audience unable to audit the result, and a culture of speed where the demo comes first. As long as generators don't make security flaws impossible to ignore — real RLS enforced at generation time, deployment blocked when a user table is left open — every week of production will add thousands of open doors to the web.

Choosing your tool carefully still matters, but no selection exempts you from the test: final responsibility never falls below the person who clicks "Deploy".


❌ Common Mistakes

Mistake 1: "My Security Advisor is green, so I'm protected"

Supabase's advisor only flags disabled RLS, not what the policies allow. A using (true) policy passes the check while letting anyone who holds the public key read everything. Solution: the manual test with the anon key, complemented by the two-account test.

Mistake 2: "It was Lovable that got hacked, nothing to do with my app"

No platform intrusion is involved: it's the apps themselves that expose their tables, through absent or permissive RLS. Solution: audit your app today instead of waiting for the platform — or a journalist — to do it for you.

Mistake 3: "My app is too small to interest anyone"

The researchers found 159,041 projects without any particular effort, through a simple public crawl. What's more, PostgREST error messages reveal your database schema via their hint field. Solution: assume from day one that your database will be discovered, mapped, and queried.

Mistake 4: "I'll hide or rotate the anon key"

The anon key is public by design in Supabase's architecture: hiding it breaks the app and provides no protection, since the expected barrier is RLS, not the obscurity of the key. Solution: real policies, table by table, verified by the two-account test — and while you're at it, check that no service_role key is lurking in your frontend.


❓ Frequently Asked Questions

Was Lovable hacked?

No. The vulnerabilities stem from missing or misconfigured Row Level Security rules in user-created applications, not from a flaw in the platform. Lovable acknowledged this through its head of security. The data was behind a door that was simply unlocked, accessible to anyone who loaded the page.

I've used a Lovable app: has my data leaked?

Impossible to say for sure: no one has been able to establish whether the exposed data had already been scraped. Test the app you're using (does the data display without a login?), change your passwords if it managed an account, and be wary of phishing emails that could exploit data from this type of leak.

Why are both 34,545 and 24,664 mentioned?

34,545 is the number of projects using Supabase among the 159,041 scanned. 24,664 is the number of sites that returned records without authentication among those 34,545 — roughly 71% of the projects backed by Supabase. So the leak is not a marginal case: it's the majority case.

Are other vibe coding tools affected?

Yes. Skynet Watch had already documented 947 apps created with Grok Build accessible without an account, and UpGuard found 16,326 Supabase databases readable from the outside across roughly 300,000 domains examined, with no exclusive link to Lovable. The flaw is architectural: it follows the scaffolding, not the platform's brand.

What should I do first if I have a Lovable app in production?

Run the anon key test on all your tables, then the two-account test. If data comes back: enable RLS everywhere, write explicit policies, delete the data you don't need to keep, then re-test. Ten minutes, today, before any other deployment.


✅ Conclusion

Vibe coding has made building apps almost free in terms of effort; the Crissy Field study reveals the hidden price: 24,664 open doors, passports, 200,000 private chats, and 280,000 emails on the counter. Test your app with the anon key today — ten minutes is all it takes — and check out the full Crissy Field report before generating the next one.