Lovable vs Cursor: who runs your backend, and what each leaves you to check

Lovable is a hosted builder that runs your database, sign-in and hosting, and scans its backend settings on every publish. Cursor is an editor and agent with no default backend: its reviews read code, and hosting and database settings are yours unless you use its Apps hosting. On both, your app's access rules are your responsibility, and only a test of the deployed app shows what a stranger gets.

The team behind Keybrum's attacksUpdated 11 min read

In short

  • Lovable runs the backend: PostgreSQL on Supabase's open-source foundation, sign-in, storage and hosting. Cursor has no default stack; you choose and run it, or host with Apps.
  • Lovable's Quick scan reads the database rules of its built-in backend on every publish. Cursor's Bugbot and Security Review read pull requests, so settings changed in a dashboard are invisible to them.
  • Cursor Apps stop a publish that contains an API key, a token or a private key, leave .env files out and remove source maps. Apps hosted elsewhere get none of that.
  • Cursor's Apps terms say it is not responsible for your apps. Lovable's security page says your app's security requirements are yours.
  • With Cursor you own more layers: hosting, environment variables, headers and deploys come on top of the access rules.
On this page

Lovable vs Cursor: the short answer

These are two different kinds of tool, and the security question changes with the kind. Lovable is a hosted builder: it writes the code, runs the database, handles sign-in and publishes the app. Cursor is a code editor with an agent: it writes whatever you ask into your repository, and where the app runs is up to you. Cursor's cloud agents can also host what they build, through a feature called Apps.

So the comparison is less about which is safer and more about how much of the stack you own. With Lovable, you own the access rules and little else. With Cursor, you own the access rules, the hosting, the environment variables and the database settings, unless you use Apps. This page lists what each covers and what you must check before real users arrive, from each vendor's documentation as of 13 November 2026. For each tool alone, read the Lovable security guide and the Cursor app security guide.

Where each one puts your data

Lovable has a default answer. Its built-in backend is enabled by default and uses Supabase's open-source foundation: PostgreSQL, sign-in, file storage, realtime and edge functions. The browser queries the database with a publishable key, and row level security (RLS) policies decide what each visitor gets.

Cursor has no default backend. The agent writes for the stack your repository already uses or the one your prompt names: Supabase, Firebase, a Postgres database behind your own API, anything. The exception is Apps, available on paid plans with access to cloud agents. There, Cursor provisions a Postgres database automatically if the app needs one, in a hosting account isolated from every other team's and user's.

LovableCursor
What it isHosted app builder with its own backend and hostingCode editor and coding agent; optional hosting through Apps
DatabasePostgreSQL in the built-in backend, or your own Supabase projectWhatever you choose. With Apps: a Postgres database provisioned by Cursor
Sign-in for your usersBuilt into the backendWhatever you build. With Apps: private and team apps sit behind Cursor sign-in
HostingLovableYours (Vercel, Netlify, a server), or Cursor's with Apps
SecretsEncrypted Secrets, injected into edge functions and server code, never sent to the browserYour host's environment variables. With Apps, the publish stops if a file contains an API key or access token
Built-in checksQuick scan on every publish, Deep scan on demandBugbot and Security Review on pull requests; publish checks on Apps
Sees your database settingsYes: the Quick scan reviews database access rules and settingsNo, unless they are written in the repository as migrations or rules files
Certifications the vendor publishesSOC 2 Type II, ISO 27001:2022, AIUC-1. Not HIPAA compliantSOC 2 Type II attestation, ISO/IEC 27001:2022, ISO/IEC 42001:2023, AIUC-1
From each vendor's documentation, read on 13 November 2026.

Both vendors draw the line in writing. Lovable: you are responsible for ensuring your app meets the security requirements of its use case. Cursor, in its Apps documentation: Cursor provides tools and is "not responsible for your apps, including your prompts and any outputs".

What each protects by default

Lovable protects the parts it runs. Secrets are encrypted and never reach the browser. The publishable key in the bundle is public by design and gives no privileged access. Lovable says it sets up access rules automatically when it builds features that store user data, and its Quick scan reviews those rules on every publish. What remains open is the content of the rules: a policy that lets every signed-in user read every row passes as a policy.

Cursor protects the change, and the publish if you use Apps. By default nothing stands between the agent's output and production except you. Turn on its reviews and that changes: Bugbot reviews pull requests for bugs, security issues and code quality problems on each update, and Security Review checks pull requests for security bugs, risky patterns and vulnerabilities before they merge. Apps add four checks on every publish: stop on an API key or access token in a file, stop on private keys and service-account keys, leave .env files out, and remove source maps. An AI security review then reads the app's files and blocks serious issues.

One more default matters on Cursor's side. Public sharing of Apps is disabled by default for Teams and Enterprise. On individual plans you can share an app publicly, and a public app does not require Cursor sign-in. From that moment, who can read what is decided by the app's own code.

The security tools each one gives you

ToolWhat it readsWhen it runs
Lovable Quick scanDatabase access rules and settings, npm dependencies, MCP servers exposed without authentication. Not your application codeAutomatically on every publish
Lovable Deep scanEverything in the Quick scan, plus all application code across seven areasWhen you start it; scheduled for Enterprise
Lovable + AikidoThe running app: AI agents attempt exploitsOn demand, billed by Aikido
Cursor BugbotPull request diffsOn each pull request update, or on a cursor review comment
Cursor Security ReviewPull request changes; /review-security runs the same review before you pushOn pull or merge request events
Cursor Vulnerability RemediationThe codebase at restScans, then patches confirmed vulnerabilities
Cursor Apps publish checksThe files being publishedEvery publish of a hosted app

Lovable states that its built-in scanners perform static analysis. Cursor's documentation describes its reviews in terms of code: diffs, pull requests, the codebase at rest. Among all of these, only the optional Aikido pentest on Lovable sends requests to a running app. That is a reasonable design for both, and it leaves the same gap: what the deployed app actually answers.

What is the same on both

Whichever you choose, the leak is in the deployed app. The same three places decide it:

  • The rules on the data. A Supabase table without RLS is open in the same way whether a Lovable prompt or a Cursor migration created it. CVE-2025-48757 found 170 of 1,645 Lovable apps with missing or weak RLS, and nothing about that bug is specific to Lovable. On an app with its own API, the rule is the owner check in each route.
  • Keys in the bundle. A secret behind a VITE_ or NEXT_PUBLIC_ prefix ships to every visitor on both. Lovable rejects VITE_ names in Secrets, and Cursor's Apps stop a publish with a hardcoded key. A key in an environment variable on another host, exposed through a public prefix, passes both.
  • Per-user access. A reviewer, human or model, reads one change at a time. It does not sign up twice and try to open the other account's invoice. That test is the one that finds an IDOR, on either tool.

With Cursor, add the hosting layer, which Lovable handles for you: a .env file served as a page, source maps, missing headers. The exposed .env guide and the security headers checker cover those.

A self-check that works on either

Run these on your own app only, in this order. They work the same on a Lovable app and on an app Cursor's agent wrote.

  1. 1

    Look at the app from outside

    Paste its address into the free check. It shows the backend the app talks to, the keys in its JavaScript and the tables it names.

  2. 2

    Check the database rules

    On Supabase, including Lovable's backend, run the SQL below in the SQL editor. In Lovable: Database view, Manage, SQL editor. On Firebase, paste your rules into the Firebase rules checker.

  3. 3

    Search what ships for secret keys

    With a repository, build the app and run the grep below on the output. Without one, paste the published JavaScript into the API key leak checker.

  4. 4

    Ask for private data with no session

    Open the published app in a private window with the Network tab open. Copy a data request as cURL, remove the Cookie and Authorization headers and run it. A private record must not come back.

  5. 5

    Repeat as a second account

    Create accounts A and B. As A, create a record. As B, request it by its id. B should get nothing.

  6. 6

    Call your AI feature signed out

    Do the same with the request your chat or generate feature sends. If a model answers, anyone can spend your credits.

sql
-- 1. Tables in the public schema with row level security off
select tablename
from pg_tables
where schemaname = 'public' and not rowsecurity;

-- 2. Policies that let every caller through
select tablename, policyname, cmd, roles
from pg_policies
where schemaname = 'public'
  and (qual = 'true' or with_check = 'true');
Run in the SQL editor of your own project. Both queries only read the catalog.
bash
# In a repository: build, then search what ships to the browser
npm run build
grep -rnoE "sk_live_[A-Za-z0-9]{10}|sk-proj-[A-Za-z0-9_-]{10}|sk-ant-[A-Za-z0-9_-]{10}|sb_secret_[A-Za-z0-9_-]{6}|BEGIN [A-Z ]*PRIVATE KEY" dist build .next/static 2>/dev/null

# On the live address: this must not return your environment file
curl -s https://YOUR-APP.example/.env | head -n 5
No output from the grep, and no key=value lines from the curl, is what you want.

What stays your job before real users arrive

CheckOn LovableWith Cursor
Access rules on every table or routeYoursYours
Secret keys kept out of the browserYours to place in SecretsYours, on your host or caught at publish by Apps
Database settingsScanned on the built-in backend; yours on your own Supabase projectYours
Hosting: headers, exposed files, source mapsRun by Lovable; check the result from outsideYours, or handled in part by Apps
Framework and dependency updatesCritical npm findings flagged by the Quick scanYours: npm audit, and the Next.js CVE checker if you use Next.js
A test of the live app after each deployYoursYours

Many people use both: Lovable for the first version, then Cursor on the exported repository. In that case the two columns add up, and the database keeps whatever policies it had the day you moved. The vibe coding security checklist lists every item.

What Keybrum tests on each, and what it does not

Keybrum is the automated pentest we build for apps made with AI. It attacks the published app from outside, so it does not matter which tool wrote the code. What it tries depends on the stack it finds.

  • Supabase backend, Lovable's included: reads, inserts and updates on every table it finds, as a stranger and as a freshly signed-up account; one account's rows read from a second account; database functions, storage buckets, realtime channels and edge functions that look like AI endpoints.
  • Firebase backend: Firestore, Realtime Database and Storage rules, tested as a stranger.
  • Your own API, common with Cursor: every route your JavaScript calls, with no session; a marked record created by one account and requested by another; Next.js middleware bypasses proved by behaviour; an unsigned event sent to your Stripe webhook.
  • Any stack: secret keys in the bundle, each checked with a read-only call; a served .env file, a .git folder, source maps and security headers.

What it does not do: it does not test Cursor itself, the agent on your machine, your rules files or your pull requests. It does not read your Lovable project or its chat. A private Cursor App behind Cursor sign-in is not reachable by a stranger, and Keybrum tests what answers from outside. It only attacks apps whose owner proved ownership. Cursor's agent can read Keybrum's findings and fixes through its MCP server; in Lovable you paste the fix into the chat.

A one-time report costs €49. Plans start at €29 a month excluding VAT for 5 apps and attack again on every deploy.

Questions

Is Cursor or Lovable more secure?

They cover different ground. Lovable runs the backend and scans its settings on every publish. Cursor reviews code changes and leaves hosting and database settings to you, unless you host with its Apps feature. In both cases the access rules of your app are yours, and they decide what leaks.

Should I start in Lovable and move to Cursor?

Many builders do. From a security view, the move changes who watches what: Lovable's publish scan stops covering the project, and your repository, host and database settings become yours to check. Run the database queries on this page on the day you move, since the policies come with you unchanged.

Does Cursor host apps like Lovable does?

Yes, through Apps, on paid plans with access to cloud agents. Cursor provisions a Postgres database if needed, puts private and team apps behind Cursor sign-in and runs publish checks for hardcoded secrets, credential files, .env files and source maps. Apps hosted elsewhere get none of those checks.

Do Bugbot or the Lovable scan test my live app?

No. Bugbot analyzes pull request diffs, and Lovable describes its built-in scanners as static analysis. Lovable offers an optional AI pentest by Aikido that does interact with the running app. Otherwise the live test is yours to run.

Which one is better for a non-developer?

This page compares security only. On that point, a hosted builder leaves you fewer things to configure, and so fewer things to get wrong outside the access rules. With an editor and your own hosting, you also own environment variables, headers and deploys.

Sources

  1. 1.Security overview, Lovable Docs
  2. 2.Built-in backend, Lovable Docs
  3. 3.Secrets, Lovable Docs
  4. 4.Control who can access your app's data, Lovable Docs
  5. 5.Database, Lovable Docs
  6. 6.FAQ: tech stack and compliance, Lovable Docs
  7. 7.Apps (hosting, publish checks and terms), Cursor Docs
  8. 8.Security Agents, Cursor Docs
  9. 9.Bugbot, Cursor Docs
  10. 10.Security, Cursor
  11. 11.Row Level Security, Supabase Docs
  12. 12.Statement on CVE-2025-48757, Matt Palmer

Your app is public. So are its mistakes.

Check what any attacker can already see in it, free, in ten seconds. The full attack, with proof and fixes: €49 once, or €29 a month on a plan.

or continue with Google or GitHub