UrgisoftAI-built apps

AI-built apps · November 2026

Is your Lovable or Bolt app secure? Six checks you can run yourself

Short answer: the question that matters before real customers arrive is "can one user read or change another user's data?" You can test it yourself in about 20 minutes, in your own browser, with two test accounts. The six checks below cover the holes AI builders leave most often; each has the fix.

Why check at all

An app built with Lovable or Bolt talks to its Supabase database straight from the visitor's browser, with a key anyone can read. That is by design, and it is safe only when every table has rules (row level security) saying who may see which rows. When a rule is missing, nothing looks broken: the app works, and so does a stranger's request. A public security report from 2025, CVE-2025-48757, describes exactly this in sites generated by Lovable up to April 2025: missing rules let people who were not logged in read or write database tables. Builders have added their own scans since then; a scan does not replace testing your own app.

What each check answers

CheckQuestionTime
1. The stranger testCan someone who is not logged in read a table?3 min
2. The two-user testCan user B read or change user A's data?8 min
3. Supabase's own advisorWhich tables have no rules, or rules that let everyone in?2 min
4. Secret keysIs a key that must stay private sitting in the browser?3 min
5. Who decidesCan a user make themselves an admin, or change a price?3 min
6. Files and functionsCan a stranger open uploads or call your server functions?3 min

The six checks, and the fix for each

  1. The stranger test. Open your live app in a private window, without logging in. Open the browser's tools (right-click, Inspect), go to Network, and reload. Click any request to an address ending in supabase.co: the address is your project, and the apikey line under Request Headers is the public key. Then paste this in the Console, with your own values and the name of a table that holds user data (profiles, orders, messages):
    fetch('https://YOUR-PROJECT.supabase.co/rest/v1/YOUR_TABLE?select=*&limit=5', {
      headers: { apikey: 'YOUR_PUBLIC_KEY', Authorization: 'Bearer YOUR_PUBLIC_KEY' }
    }).then(r => r.json()).then(console.log)
    Good: an empty list [] or a permission error. Bad: rows of real data. Then anyone on the internet can read that table.
    Fix: turn on row level security for the table and add a rule for each action, for example using (auth.uid() = user_id) for reading. Do this for every table, not only the one you tested. A table that is meant to be public (a product list) still needs row level security on, with a read-only rule.
  2. The two-user test. This is the one a paying customer will ask about. Create two test accounts, A and B, in two different browsers (or one normal and one private window). As A, create something: a note, an order, a project. As B, open Network, filter by rest/v1, and click around until you see a request to the same table. Right-click it, Copy, Copy as fetch, and paste it in B's Console. Before running it, delete the filter from the address (the part like &user_id=eq.…), so it asks for every row.
    Good: B gets only B's rows. Bad: A's record is in the answer.
    Then test changing: in the same pasted request, set the address to A's record (?id=eq.A-RECORD-ID), add method: 'PATCH' and a body with one changed field, and run it. Reload as A: the record must be unchanged. If your app has teams or companies, repeat with two users from two different teams; that is the same test one level up.
    Fix: the rule must compare the row's owner with the logged-in user, on the server: using (auth.uid() = user_id) for read, update and delete, and with check (auth.uid() = user_id) for insert and update. For teams, the rule checks a membership table, not a team id sent by the browser. A rule that says using (true) lets everyone through; hiding rows with a filter in the app's code protects nothing.
  3. Supabase's own advisor. In the Supabase dashboard, open Advisors, Security Advisor. It lists tables in the public schema with row level security off, tables with rules written but row level security never turned on, and rules that let everyone through. In the Table Editor, a table without row level security carries an "Unrestricted" label.
    Fix: clear every error on that page. The advisor reads settings, not behaviour: a rule can exist and still be wrong, which is why checks 1 and 2 come first.
  4. Secret keys. Supabase has two kinds of key. The public one (sb_publishable_…, or the older anon key) belongs in the browser. The secret one (sb_secret_…, or the older service_role key) skips every rule and must never be there. On your live app, open the browser's tools, press Ctrl+Shift+F (Cmd+Option+F on a Mac) and search the loaded files for service_role, sb_secret_, sk_live (Stripe), sk-proj- (OpenAI) and sk-ant- (Anthropic). The older Supabase keys both start with eyJ; paste the one your app uses into a JWT decoder and read the role: it must say anon.
    Fix: a secret found in the browser is already public. Replace it in the service's dashboard first (make a new key, delete the old one), then move the call that needs it into a Supabase Edge Function or your host's server function, and keep the key in that function's secrets. In a Vite app, any setting whose name starts with VITE_ is built into the files every visitor downloads.
  5. Who decides. Anything the browser sends can be changed by the person using it. As test user B, repeat the pasted request from check 2 against your own profile row, with method: 'PATCH' and a body such as {"role":"admin"} or {"plan":"pro"}, using your own column names. Reload: if B is now an admin or on the paid plan, anyone can do the same. Look also at checkout: if the browser sends the price, a buyer can send a lower one.
    Fix: keep roles and plans in a table users cannot write to, and check them inside the rules or in a server function, never only in the page. Prices come from the server or from Stripe's own price ids; "paid" is set only by a Stripe webhook whose signature the function verifies.
  6. Files and functions. Upload a file as user A, copy its address, and open it in the private window. If it opens, the storage bucket is public: fine for product photos, not for invoices or ID scans. Then find a request to /functions/v1/ in Network (if your app has any), copy it as fetch, remove the authorization line and run it in the private window.
    Good: the function refuses (401). Bad: it does its work for a stranger, on your bill if it calls a paid AI service.
    Fix: make private buckets private, add storage rules by owner, and show files through signed links that expire. In each function, read the caller's login from the request and refuse when it is missing; do not trust a user id sent in the body.

This is a checklist from engineering practice, not a study, and not a full security audit: passing all six does not prove an app is secure, it shows the most common holes are closed. Test only your own app, with your own test accounts. Supabase renames its menus from time to time. It covers React apps with a Supabase backend, which is what Lovable and Bolt set up by default.

Other problems

Nobody can log in on the live site? Login and Supabase errors: seven causes and the fix for each. The app shows nothing at all? A blank page after publishing: six causes. Moving it to your own host? Deploy to Vercel or Netlify: the steps, and six errors that stop it. Slow on phones? Our demo shop, measured before and after: 14.5 s to 1.4 s.

Want it fixed for you?

Closing a hole one of these checks found is a bug fix like any other. We fix apps made with Lovable, Bolt, Replit, Cursor and other AI builders, in your own code, and tell you in plain words what was wrong. Fixed prices on Fiverr: one bug from $40, up to five bugs with the app deployed and working live from $150. No fix, no charge. A GitHub invite is enough; we never ask for passwords.

See the gig on Fiverr