Is my Lovable app safe to launch?

A checklist for the hour before you share the link. Each step says what can go wrong, how to check it yourself, and where a scan helps.

No checklist can promise an app is secure. What it can do is catch the mistakes that cause most real trouble in apps built quickly: keys in the wrong place, data that's readable by anyone, and settings left on their development defaults. Work through these in order.

1. Run Lovable's own security scan

Start inside Lovable. Its security scan runs a quick check when you open the publish dialog (database access rules, dependencies, MCP server exposure), and you can run a deeper one from the Security view. Fix what it reports, especially anything critical. Lovable's documentation is clear that "no issues found" isn't a guarantee, which is why the rest of this list checks the live app too.

2. Make sure no secret key is in the front end

Everything in your app's front end is downloaded by every visitor. Open your published site, open the browser's developer tools, and search the loaded JavaScript for sk_live, sk-, service_role and the names of any services you use.

Keys for paid services (Stripe secret keys, OpenAI, Anthropic, email providers) belong in Lovable's secrets, which are encrypted and only given to your Edge Functions. Your page calls the Edge Function; the function calls the service.

Two keys are meant to be public: the Supabase publishable (anon) key and a Stripe publishable key starting pk_. Leave those alone.

Scan help: the free scan runs these, among others:

  • #1 Stripe live secret key exposed Free
  • #2 OpenAI API key exposed Free
  • #3 Anthropic API key exposed Free
  • #5 Supabase service key exposed Free
  • #10 Secret values in public env variables Free
  • #112 Database connection string with password exposed Free

3. Check what the public Supabase key can read

Most Lovable apps use Supabase. The browser talks to it with the public key, and Row Level Security decides which rows that key can see. Supabase's RLS docs explain that once RLS is enabled, nothing is readable through the API with the public key until you add policies.

For each table, ask: who should read this? Everyone (a list of products), only the owner (orders, messages, profiles), or nobody from the browser (internal data)? Then make sure the policies say exactly that. Our RLS guide walks through the common patterns.

Do the same for storage buckets that hold user uploads, and for database functions: a function can be called with the public key unless you revoke that.

Scan help: on a domain you verify, the Deep scan tries this from outside with your public key and, with two test logins, checks whether one user can see another's data:

  • #59 Supabase tables not readable with the public key Deep
  • #60 Supabase storage buckets not listable Deep
  • #147 Database functions not callable by anyone Deep
  • #96 Data isolation between users Deep
  • #97 User files and profiles isolated Deep

4. Review your sign-up settings

In Supabase, under Authentication, check three things:

  • Email confirmation. If it's off, anyone can sign up with an address they don't own.
  • Redirect URLs. Social logins should only send people back to your own site. Supabase's redirect URL docs explain the allow list.
  • Site URL. If it still says localhost, emails and logins will point at your own computer.
  • #117 Sign-ups confirm the email address Pro
  • #120 Social login only returns to your own site Pro
  • #121 Auth Site URL isn't localhost Pro

5. Check HTTPS and security headers

Your app should load only over HTTPS with a valid certificate. Headers like HSTS and a Content-Security-Policy protect visitors against downgraded connections and injected scripts. You can check these on their own with our security headers checker.

6. Make sure nothing extra is being served

Source maps let anyone read your original code. They're not always a disaster, but if your code contains anything sensitive, turn them off for production. Environment files and backups should never be reachable.

  • #11 .env file public Free
  • #13 JavaScript source maps public Free
  • #14 Backup files public Free

7. Add the pages your users expect

If you collect emails or take payments, you need a privacy policy and terms, and payment providers expect clear refund and contact information. Whether a particular law applies depends on where you and your users are, so check what applies to you. Pro checks these, and every finding names the law or rule it's based on.

8. Scan the published address

Finally, check the app the way a stranger sees it. Paste your lovable.app address or custom domain into the scan box. The free scan runs 46 tests in about a minute; Pro runs 130 for $10, one payment.

If you find a problem after launch

It happens. The order matters more than the speed:

  1. Close the hole first. Turn on RLS, tighten the policy, or remove the key from the code and publish again.
  2. Rotate anything that was exposed. A key that was public stays usable until you revoke it at the provider, even after you remove it from your code.
  3. Look for signs it was used. Check your provider's usage and logs, and your Supabase logs, for activity you don't recognise.
  4. Check it's really fixed. Run the same check again on the live address, not the preview.

If personal data may have been read by someone who shouldn't have it, data protection laws in some places expect you to act within a set time. Check what applies where you and your users are.

Keep checking after launch

Every new prompt can change your app. A feature that adds a table, an integration that needs a key, or a quick fix for a CORS error can undo something you checked last week. A simple habit: re-run your checks after each bigger change, and before you share the app with a new group of users.

A short version to keep

  • Lovable's scan: run, fix critical findings.
  • No secret keys in the front end; secrets in Lovable's secrets.
  • RLS on every table, policies that match who should read.
  • Storage and database functions locked down too.
  • Email confirmation on, redirect URLs limited, Site URL set.
  • HTTPS and headers in place.
  • No source maps, env files or backups served.
  • Legal pages if you collect data or take payments.
  • Scan the live address, fix, scan again.

Questions

Lovable's scan found nothing. Am I done?

It's a good sign, not a guarantee, as Lovable's own docs say. Also check the published app from outside: keys in the built code, what the public database key can read, and your auth settings.

Is my Supabase anon key in the code a problem?

No. It's designed to be public. What matters is what your Row Level Security policies let that key read.

How long does this checklist take?

Steps 2 to 6 take about an hour the first time if you check by hand. A scan does most of the outside checks in a minute or two, and then you fix what it finds.

Check your live app now

Paste your app's address. The free scan runs 46 tests and shows proof for everything it finds.