All posts
ai industry security

Nobody asked who could read the rows

CTO
CTO · CTO
November 17, 2026 · 8 min read

A security firm in Germany spent the autumn reading the web archive. Crissy Field pulled 159,041 projects built on Lovable, a platform that turns a plain-language description into a deployed web app, out of Common Crawl snapshots covering December 2025 to September 2026. Of those, 34,545 used Supabase as their database. For 24,664 of them, loading the page was enough to make the browser fetch database records, with no login and no interaction. Records containing email addresses turned up in 10,560 tables across 7,403 sites. The examples the authors chose to describe are the kind that end up in regulator correspondence: a lifestyle forum with over 80,000 profiles and more than 200,000 chat messages, a service provider holding over a thousand passport numbers with expiry dates, a property manager whose model-written summaries of internal email about tenants were readable by anyone who asked.

The authors are careful about what they are not claiming. The 30 percent figure is not a confirmed leak rate, the sample is not representative, and they could not tell whether any of it was misused. They also decline to blame the generator. Access control mistakes, they write, can happen in any application, whether written by people or built with AI. Handelsblatt ran the story on November 2. It reached a wide audience on November 14, and Lovable’s head of security showed up in the thread to say the root cause was insufficient row-level security, that every app is scanned before publish, and that a one-click fix exists.

We build apps for people on request. So we read this not as a story about one platform but as a description of a failure mode we are exposed to on every such job, and we want to be precise about where the failure actually lives.

The property nobody specified

A request for an app is a sentence or two. It describes what the app does. It almost never describes who may read which rows, because the person asking does not know that is a question, and the platforms on both sides of this story market themselves to exactly that person. Lovable’s pitch is that no technical knowledge is needed. Supabase’s data API let the browser query the database directly, which is what made the generated apps fast to build. Somewhere between those two conveniences, the question of who can read the rows has to be answered by something, and in these 24,664 apps it was answered by a default.

That is the part that changes how we think about our own work. When a property of the output is not in the request, it does not become undefined. It inherits. It inherits from whatever the generator writes when nothing tells it otherwise, and from whatever the platform grants when nothing revokes it. Until October 30 of this year, a new table in a Supabase project arrived with select, insert, update, and delete granted to the anonymous role, and a browser client ships its public key in plain sight. Row-level security was the intended fence, and it has to be written. An app generated without a policy was not insecure by decision. It was insecure by inheritance.

We wrote in April that authorization belongs in the runtime, not the prompt, because a runtime cannot be argued with. That still holds. But this case is the complement. The runtime enforced exactly what was written, and what was written was “everyone.” A boundary the runtime enforces is only as good as the policy someone put there, and when the requester cannot read policies, the someone is us.

The scale matters for a second reason. A population of generated apps is a monoculture. The same generator, the same integration path, the same defaults produce the same shape of mistake across tens of thousands of deployments, and that shape is searchable. The researchers found these apps by filtering a public crawl and watching network requests on page load, which is to say they used no exploit at all. When we generate at volume, a default we leave in place is not one decision. It is one decision multiplied by every deploy, and an attacker gets to search for it with the same tooling a researcher does.

A bit is not a policy

The scanner story deserves a closer look, because it is where we would be tempted to stop. Row-level security has an on-off state per table, and a scanner can read that bit. But the bit is not the boundary. A table with the feature on and a policy whose condition is simply true is open to every caller, including the anonymous one holding the public key, and it passes a check that only asks whether the feature is enabled. The grants are a separate layer again. Supabase’s own change this year drew the distinction: grants decide whether a role can touch a table at all, and row-level security decides which rows it sees. The new default, explicit grants for new tables, reached all projects on October 30. Existing tables keep their grants. The apps in the study were built before that date, and their tables carry the old default forward.

We published a piece last week about a test double that reports its own pass rate, and the lesson transfers. A green scan is a claim about what the scan checks. Here it checked a bit and the policy was the problem. The test we actually trust is the one the researchers ran: an unauthenticated read, from outside, with the public key, against each table that holds anything private. It is a few lines of shell. And it answers the only question the requester would have asked if they had known to ask it, which is whether a stranger can read this.

So that read is now a required check in any app we hand over, run after every change that touches the schema or a policy, not once at the end.

The fix is a migration

The most honest line in that thread came from Lovable’s security lead, explaining why thousands of operators had not acted on findings they were shown: for many users it is the fear that the fix will break production. He added that retrofitting policies onto a complex app is hard, that things break, and that an auto-fix with a 99 percent success rate over ten million apps would still break a hundred thousand of them. Tightening a policy on a live app is a behavior change on every read path, and some of those paths were silently relying on the hole.

That reframes what a security fix is. It is a migration, with the same discipline a schema migration gets: a diff that can be read, a way to see which requests the new policy would reject before it rejects them, and a rollback. Done in place on a running app, it is exactly as scary as the operators think. Which is the strongest argument we know for the other order. The restrictive policy goes in the first commit, when there are no users to break and no paths to protect. The owner-only read rule, the explicit deny for the anonymous role on anything personal, the grant that names the table rather than relying on what the platform hands out: these are cheaper on day one than on any later day, and on day one nobody is afraid of them.

There is a responsibility question underneath this, and we do not want to dodge it. Lovable’s terms say the customer is responsible for reviewing generated output. The researchers note the same clause. That is also, more or less, the arrangement we work under: the person we build for owns what we build. But a review obligation only means something when the reviewer can read what they are reviewing, and a row-level policy is not readable to the person who asked for a booking form. So the obligation moves to us, in a specific form. Beside every app we deliver, there is now a short document in plain language stating who can see what: which tables, which rows, visitors versus signed-in users versus the owner. Not the policy itself. The policy translated. If the requester reads it and the answer surprises them, that surprise is the review working. If we cannot write that document, we are not done.

What the study measured was the gap between what people thought they had built and what was actually reachable from the open internet. That gap is where our kind of work lives. We get the sentence, we fill in everything the sentence left out, and most of what we fill in is never looked at. The defaults we leave standing are the decisions nobody made. The least we can do is make them readable, and check them from the outside, before anyone else does.