It means a table in your database has row-level security turned off, so anyone with your project's address and the public key in your app can read, change or delete its rows. Supabase's own page for the check calls that "a critically unsafe configuration" (Supabase's own docs). The fix is to turn row-level security on, then write rules that let each person reach only their own rows.

What the warning means

Row-level security, or RLS, is a set of rules inside your database that decides who can see and change each row. Supabase checks every table in your public schema, the part of your database your app reaches through Supabase's API. When a table there has no RLS, its Security Advisor marks it as an error and names the table: "Table public.your_table is public, but RLS has not been enabled." Supabase also emails project owners when a table is created that way, and sends organization owners a weekly security summary (Supabase's January 2026 security post).

Who can read your data right now

Possibly anyone. Your app carries a public key, called the publishable key (or, on older projects, the anon key). That's by design: anyone using your app can see it. RLS is what stops that key from opening every table. Until it's on, anyone holding the key can read and write every row in the table (Supabase's table docs).

What to do today

  1. List the tables Open the Security Advisor in your Supabase dashboard. It names each table with RLS off.
  2. Turn RLS on for each one Run this in the SQL editor, once per table, with your table's name:
alter table public.your_table enable row level security;
  1. Expect parts of your app to go blank Once RLS is on, the public key can't reach any rows until you write a policy (Supabase's RLS docs). That's the safe default. Your app comes back as you add policies.
  2. Write a policy for each thing your app does Reading, adding, changing and deleting each need their own rule. The example below lets each signed-in person reach only their own rows.
  3. Test it signed out, in your app Not in the SQL editor: it runs as the table's owner, which skips policies, so it still shows every row (Supabase's table docs). Open your app in a private window, signed out, then as a second test account, and confirm each sees only what it should.
  4. If the table held private data Check what to do next on our security checklist, including when to talk to a lawyer about telling your users.

Why "using (true)" only hides it

The quickest way to clear the warning is a policy with using (true). It turns RLS on, so the warning goes away, but it lets every signed-out visitor read every row (Supabase's RLS docs). Your data is just as open as before. And Supabase's own check for always-true policies skips read policies on purpose, because some data really is meant to be public, so nothing will warn you again. Use it only for data you'd post on your website, like a list of products.

A policy that works

This pair lets each signed-in person see and add only their own rows. It assumes the table has a user_id column that holds each row's owner. Change the table and column names to match yours.

create policy "Users see their own rows"
on public.your_table for select
to authenticated
using ( (select auth.uid()) = user_id );

create policy "Users add their own rows"
on public.your_table for insert
to authenticated
with check ( (select auth.uid()) = user_id );
  • to authenticated Signed-out visitors never get past this line.
  • (select auth.uid()) The signed-in person's ID. Wrapping it in select lets the database work it out once per query, which keeps it fast (Supabase's RLS docs).
  • using and with check using decides which existing rows someone can see or change. with check decides what a new or changed row is allowed to look like. A policy for changing rows usually needs both.

The keys: which is safe where

  • Publishable key (sb_publishable_, or the older anon key) Meant to be in your app: Supabase calls it safe to expose on a web page (Supabase's API key docs). Safe only when RLS is on.
  • Secret key (sb_secret_, or the older service role key) Full access to your data, skipping RLS (Supabase's API key docs). Only on your server or in edge functions, never in browser code, and that code has to check who's asking itself.
  • The older keys are being retired Supabase is retiring the anon and service role keys by the end of 2026 in favor of the new ones (Supabase's API key docs).

RLS on, but still not working?

  • RLS is on, but nothing comes back There's no policy yet, so no rows are returned (Supabase's check 0008). Add one.
  • A policy exists, but RLS is off The policy does nothing until RLS is on (Supabase's check 0007).
  • A view shows every row Views skip RLS by default. On Postgres 15 and later, create them with security_invoker = true so they follow the table's policies (Supabase's RLS docs).
  • The SQL editor shows every row It runs as the table's owner, which skips policies (Supabase's table docs). Test in your app, signed out.
  • File uploads fail Storage has its own policies, on storage.objects. Without them, no uploads are allowed (Supabase's Storage docs).

If you built with Lovable, Bolt or another AI tool

Supabase's Table Editor turns RLS on for tables made in the dashboard. Tables made with SQL, including by AI tools, need it turned on by hand (Supabase's table docs). Lovable sets up basic policies for you, but its own docs say to review and adjust them early (Lovable's own docs), and its quick scan, which runs each time you publish, checks for tables without RLS and rules that let everyone through (Lovable's security docs). A clean scan means the rules exist. It doesn't mean they're right for your app. A person reading them catches the difference, as our security checklist explains.

Want us to check it?

Our Production Ready review is a senior read of your app, delivered within a week. We read every table's rules, check the keys and the logins, and give you a ranked list of fixes in plain words.

Common Questions

Frequently asked questions

What does "RLS disabled in public" mean in Supabase?

A table in your public schema has row-level security turned off. Your app reaches that schema through Supabase's API, so anyone with your project's address and the public key in your app can read, add, change or delete that table's rows. Turn row-level security on, then add policies that let each person reach only their own rows.

Do I need RLS in Supabase?

Yes, on every table your app reaches through Supabase. Without it, the public key in your app opens the table to anyone. Even data meant to be public should have row-level security on, with a policy that only allows reading.

Why is my Supabase RLS policy not working?

The usual causes: row-level security is on but there's no policy, so nothing comes back; a policy exists but row-level security is off, so the policy does nothing; a view skips your policies; or you tested in the SQL editor, which skips policies and shows every row. Test signed out, in your app, instead.

Should I hide my Supabase publishable or anon key?

No. That key is meant to be in your app, and anyone using the app can see it. Row-level security is what protects your data. The secret key, or the older service role key, is different: it skips row-level security and must never be in browser code.

Proof

How we built Deliberate with Claude Code

Deliberate is our own Mac app, built by a three-person team with Claude Code. We built the app, its registration and billing site, and integrations with Gmail, Outlook, Slack, Asana, Zoom and Granola. It runs on your Mac, never saves the full text of your email, and sends nothing without your yes.

Meet Deliberate

Want a second set of eyes on your rules?

Send us the link and the warning you got. We'll tell you what we'd fix first.