
If you built an app with an AI app builder and connected a Supabase database, there is one question worth answering today: can a stranger read your tables without logging in? For a lot of apps the answer is yes, and the owner has no idea.
That is the finding of a new report from Crissy Field, a German security firm that worked with the newspaper Handelsblatt. It examined 159,041 Lovable projects found in the Common Crawl web archive from December 2025 to September 2026. Among the exposed data: more than 200,000 private chat messages from one forum, and more than 1,000 records with passport numbers from one service provider.
Below: what the researchers found, why it happens (it is not really a Lovable bug), how to check your own app in about 20 minutes, how to fix what you find, and what Lovable says it now does about it. The same checks apply to any app on Supabase, whether you built it with Lovable, Bolt, a coding agent or by hand.
What the researchers found
The method was simple and read-only. Of the 159,041 projects, 34,545 used Supabase. On 24,664 of those sites, the page sent database records from Supabase as soon as it loaded, with no login. That on its own can be fine, since some data is meant to be public. The researchers then made further read-only requests with the same public key the site itself used, and found records with email addresses in 10,560 tables across 7,403 of those 24,664 sites, or 30%.
The cases they describe are not test data:
- A German lifestyle forum exposed more than 80,000 profiles with full names, email addresses, dates of birth and gender, plus more than 200,000 chat messages.
- Event organizers and restaurants exposed tens of thousands of ticket and food sale records, with email addresses, phone numbers, postal addresses, payment information and ticket codes.
- A property management company exposed AI-generated summaries of internal emails about tenants, owners and partners.
- A service provider exposed more than 1,000 records with passport numbers, expiry dates and nationalities.
- In one case, 280,000 emails sent to a provider's customers were accessible.
The report is careful about its limits. An email address does not always mean personal data, the sample is not representative of every Lovable app, and the 30% figure is not a confirmed leak rate. It also deliberately leaves out how to reach the data. The direction is still clear: a meaningful share of apps built this way leave private rows open.
Why this happens: the public key is public on purpose
Supabase gives every project a public (anon) key that ships inside your frontend code. That is by design. Anyone can open your site, view the source and copy it. The key is not what protects your data. What protects your data is Postgres Row Level Security (RLS): policies on each table that decide which rows a given request may read or change.
So the failure is almost always one of these:
- RLS is off on a table. Then anyone holding the public key can read the table through the auto-generated API.
- RLS is on, but a policy allows everything. A select policy with a condition of simply true, granted to anonymous users, is the same as no protection for that table.
- A view or function bypasses RLS. By default, a Postgres view runs with its owner's rights, so a view over a protected table can quietly expose it.
- A storage bucket is public. Files in a public bucket can be fetched by anyone who has, or guesses, the URL.
- The secret key is in the frontend. The service role key bypasses RLS completely. If it is in your client bundle, nothing else matters.
Why do AI-built apps land here so often? When you ask a builder for a feature, it creates the table and wires the page to it. Whether the access rules are strict depends on what you asked for and on whether anyone checked. "Add a contact form that saves to the database" gets you a working form. It does not necessarily get you a rule that stops a stranger reading every submission.
The researchers make the point that matters most for builders: apps generated by the same platform follow the same patterns, so one misconfiguration that works against one app may work against many others with little extra effort. Your app does not need to be famous to be found.
Step 1: Run the Security Advisor
Open your project in the Supabase dashboard and go to the Advisors section, then Security Advisor. It lists known problems by name, including tables in the public schema with RLS disabled and views defined with security definer. Fix every error before you look at anything else. It takes a minute and catches the most common case outright.
Step 2: List every table and its RLS state
In the SQL editor, run:
select tablename, rowsecurity from pg_tables where schemaname = 'public' order by tablename;
Any row with rowsecurity set to false is a table your public key can reach. Then list the policies:
select tablename, policyname, roles, cmd, qual from pg_policies where schemaname = 'public' order by tablename;
Look for select policies whose condition (qual) is just true, and for policies granted to anon or public on tables that hold anything personal: profiles, messages, orders, tickets, invoices, uploads, waitlists, contact forms. A waitlist is still a list of email addresses.
This is a good job for a coding agent. Ask it to run both queries, then return a table of every table with its RLS state, its policies and a one-line guess at whether it holds personal data. Tell it not to change anything yet.
Step 3: Test as a stranger, against your own project
Queries tell you what the rules say. A test tells you what actually happens. Open your own site in a private browser window without logging in, open the network tab and look at the requests to your Supabase project. Then, for each table you are unsure about, request it the way a logged-out visitor would, using your own project URL and the public key from your own frontend:
curl "https://YOUR-PROJECT.supabase.co/rest/v1/YOUR_TABLE?select=*&limit=1" -H "apikey: YOUR_PUBLIC_KEY"
If a private table returns rows, you have found the problem. An empty list or a permission error is what you want. Only ever run this against projects you own.
Step 4: Fix what you find
The fixes are short, but test each one, because a too-strict policy breaks your own app:
- Turn RLS on for every table in the public schema: alter table public.messages enable row level security;
- Write owner-only policies for private data, for example: create policy "own rows" on public.messages for select to authenticated using ((select auth.uid()) = user_id);
- Remove any select policy that is just true on a table that holds personal data. Keep public reads only for data you would happily publish on your homepage.
- Make views respect RLS with alter view public.my_view set (security_invoker = true); or move them out of the public schema.
- Make storage buckets private unless every file in them is meant for everyone, and serve private files through signed URLs.
- Search your frontend bundle for the service role key. If it is there, move the code that needs it to a server function and rotate the key.
After each change, repeat the logged-out test from Step 3, then log in as a normal user and check the app still works.
What Lovable says it does now
In a post published on November 10, Lovable's head of security writes that every publish runs scanners over your code, database schemas and row-level security policies, and warns you before the app goes live. It offers a free deep scan, a Fix button that hands the issue to its agent, an "Auto-fix security issues" setting, and publishing controls that can block a release with critical findings. It names data access rules that are too open as the most common issue it sees.
That helps, and you should turn it on. But the same post says what is still on you: reviewing the findings and acting on them. The researchers go further and recommend an expert review of access permissions before an app handles real customer data, repeated after significant changes. A scanner is a floor, not a sign-off.
Practical takeaways
- The public Supabase key is meant to be public. Row Level Security is what protects your data.
- Run the Security Advisor first, then list every public table with its RLS state and policies.
- Treat any select policy that is just true on personal data as an open door.
- Test as a logged-out visitor against your own project, not just by reading policies.
- Check views, storage buckets and your bundle for the service role key, not only tables.
- Use your builder's security scanner, act on every finding, and get a human review before handling real customer data.
Conclusion
AI app builders made it possible to ship a working app with a database in an afternoon. They did not make access control automatic, and the Crissy Field scan shows what that gap looks like at scale: private messages, ticket buyers and passport numbers readable by anyone with a public key. The check above takes about 20 minutes. Do it before your next user signs up, and again after every big change.
We found this through the weekly feed in the HelloBuilder newsletter, where it ran under AI News. The full report, with its method and limits, is Crissy Field's research page.


