November 14, 2026 · Updated November 17, 2026 · Security · 9 min read
Lovable and Base44 Security: Who Can See Your App’s Data?
Staticbot keeps Base44 login requirements in place and shows you which tables may be open to visitors or all signed-in users. Understand what it checks when you move your app, and what to review before going live.
Ravel works on Staticbot’s migration platform, moving apps built with Lovable and Base44 onto Supabase and hosting their owners control.
Your product catalog may be public. Your customers’ orders, private messages, and account details usually shouldn’t be. A login screen alone does not tell you whether that data is protected: someone may be able to ask the database for it directly, without using your app’s screens. Crissy Field’s research on sensitive data exposure in Lovable apps documents this risk in real apps.
Staticbot helps you review who can reach your data when you move from Lovable or Base44 to your own Supabase. It keeps a Base44 app’s sign-in requirement in the database rules it creates, and checks for common access problems in the tables that hold your app’s data. It shows you the table names, whether access is possible without signing in, and whether people may be able to read or change the data.
For Lovable, Staticbot brings over your existing access rules and flags common signs of open access. You can then decide which data should stay public and which permissions need changing before you share the preview or go live.
What Staticbot does for your app
- Keeps Base44’s login requirement. If Staticbot can confirm that your Base44 app requires sign-in, it keeps that restriction in the table-access rules it creates in Supabase. A rule that says “anyone” still means people who have signed in to the app.
- Shows you tables that may be open. Staticbot checks for common permission settings that can expose a whole table. The report names the tables and tells you whether the possible access involves reading, adding, changing, or deleting records.
- Distinguishes visitors from signed-in users. A table open to everyone on the internet is different from a table open to every account holder. Staticbot shows these separately so you can review the right risk.
- Checks again as you keep building. When Continuous Sync applies database changes from your builder, Staticbot checks for these access problems again.
These checks are included in the free self-service migration workflow when moving to a supported Supabase Cloud project. Public tables can be intentional, so a warning asks you to review the permissions; it does not automatically close the table or stop the app going live.
Why a login screen isn’t enough
A Supabase app includes a public connection key in its browser code. Anyone can find that key. It identifies the project; it is not a secret password that keeps visitors away from private data.
The database needs its own rules about who can see or change each record. In Supabase these are called row-level security, or RLS. For example, an orders table might let a customer see their own orders while keeping everyone else’s orders private.
Supabase documents two common access problems that Staticbot checks:
- RLS disabled: the table’s row-level protection is switched off. Staticbot flags this when database permissions allow access.
- Overly permissive RLS policies: a rule allows access to every record for visitors or signed-in users. Staticbot looks for simple “allow every record” rules alongside the database permissions that permit access.
These settings can be right for intentionally public data. For private records, a warning gives you a table and a permission to review. More complicated rules can still contain mistakes, so the automated check is a starting point for reviewing your app.
Requiring sign-in is different from protecting each customer’s records. If anyone can create an account, a rule that lets every signed-in user read every order is still too open for a private orders table.
Keeping your Base44 login requirement
Base44 manages the data rules for apps that use its built-in database. When you move one of these apps, Staticbot creates the corresponding tables and access rules in Supabase, with row-level security switched on.
If your Base44 app requires sign-in, Staticbot keeps that requirement in the rules it creates for your app’s tables. This includes a Base44 rule that says “anyone”: inside an app that requires a login, “anyone” does not mean an anonymous visitor. People without a signed-in session cannot use those rules to read or change the records.
Staticbot needs to be able to confirm the app’s sign-in setting. If that setting is unavailable, review the permissions rather than assuming the app is private. An intentionally public app can keep public access—for example, to products or published posts.
Some Base44 tables have no access rules of their own. In “Stop before each phase” mode, you can review who should use them: public readers where the app permits that, signed-in users, the person who created a record, or nobody through the app’s data connection. The app’s sign-in requirement still applies.
Check customer and administrator accounts separately after the move. Keeping the login requirement protects the table rules Staticbot creates; it does not replace a review of administrator privileges, files, or custom server-side code.
Checking access when you move from Lovable
Staticbot brings your Lovable database rules across from the export you choose, or from the database setup files in your repository. Your app keeps the access those rules describe. If a table was open before the move, it can still be open afterwards.
Staticbot points out common signs of open access on the new database. This check runs with either migration method. It names the tables, separates access without signing in from access for all signed-in users, and shows whether the possible access includes reading or changing data.
That gives you something specific to act on. Public access to a product catalog may be correct. Public access to orders or private messages probably isn’t. You own the new Supabase project, so you or your developer can change those permissions and test them before sharing the preview.
You can also fix the rules in Lovable before moving; the corrected rules come with the app. If you keep building in Lovable afterwards, keep the intended rules in your project’s database setup too, so a later update does not replace a correction made only in Supabase.
What to expect during migration and updates
| Your app | What Staticbot does | What to review |
|---|---|---|
| Moving from Base44 | Creates access rules for your app’s tables, keeps a confirmed sign-in requirement, and checks for common settings that leave data open. | Who should see each record, which actions need administrator access, and any tables without their own rules. |
| Moving from Lovable | Brings across the rules from your export or project files and checks the new database for common signs of open access. | Whether the existing rules are right for your data. Moving the app does not automatically tighten them. |
| Reviewing warnings | Shows table names, possible read or write access, and whether that access is available without signing in or to all signed-in users. | Which access is intentional. Change permissions that expose private data and test the result. |
| Keeping your builder | Checks again after Continuous Sync applies database changes. Base44 table rules created by Staticbot keep a confirmed login requirement. | Warnings after updates. Waiting to approve the new app screens does not hold back database changes that sync has already applied. |
| A check cannot run | Records that access was not verified. The automated check depends on access to a supported Supabase Cloud project. | Arrange a separate check, including for a self-hosted database. A missing result is not a pass. |
Review warnings before sharing the preview. The preview uses your new database and a copy of your data. A private-looking URL or a page that loads correctly does not tell you whether those records are private.
The check reports what it finds; it does not automatically rewrite existing permissions. If your app is already migrated, review its current database rules rather than assuming they have changed.
What still needs your attention
- One customer seeing another customer’s data. Test with two accounts, including direct requests for the other account’s private records. OWASP describes this kind of access failure as broken object-level authorization. A working login and RLS switched on do not prove that each user sees only their own records; Staticbot’s automated table checks do not establish that separation.
- Custom server-side features. Code that runs payments, sends email, or looks up records may use powerful database credentials. It needs its own checks on who can call it and which data it returns.
- Files and documents. Public storage can expose a file to anyone with its address, even when the app’s tables are protected. Review uploads and downloads separately.
- Secret keys in browser code. The public connection key belongs in the frontend; secret keys do not. Staticbot’s table checks are not a scan for secrets someone previously added to the code.
- More complicated permissions. Staticbot checks common ways tables are left open. A clean report does not prove that every permission or business workflow is secure.
Permission changes are made in Supabase by you or your developer. A warning does not apply a one-click fix. For sensitive customer data or a detailed review of permissions between users, discuss a security review as part of an Enterprise engagement.
What the report found
The risks are illustrated by Crissy Field’s report on data access in Lovable apps, covered by Handelsblatt on November 2, 2026. Its findings explain why reviewing database permissions matters; they do not measure the security of your individual app.
- From Common Crawl data, the researchers identified 159,041 Lovable projects between December 2025 and September 2026. 34,545 of them used Supabase.
- 24,664 of those sites sent database records when the page first loaded, with no login. On its own that is not a problem, because a product list or a blog is meant to be public.
- Using the same public key, the researchers made further read-only requests. They found records containing email addresses in 10,560 tables across 7,403 of the 24,664 sites (30%).
- Examples include a forum with more than 80,000 profiles and more than 200,000 chat messages, event and restaurant sites with ticket and food orders including payment information and ticket codes, and a service provider with more than 1,000 records of passport details.
The authors state the limits themselves. The 30% is not a confirmed leak rate: some email addresses are public contact details or test data, and tables without email addresses were not counted. Their sample is not representative of all Lovable apps. They examined apps using Supabase and did not examine Lovable's own database features, introduced in late 2025.
Their advice: before an app handles real customer data, review its access permissions, its interfaces and the separation between user accounts. Repeat the review after significant changes, and bring in qualified help if you lack the expertise. Automated checks, they write, are no substitute for a professional security assessment. We agree, and nothing in this article replaces one.
A practical checklist before going live
- Decide what should be public. Write down which data visitors may see, what each signed-in user should see, and which actions belong to administrators.
- Review the named tables. Read Staticbot’s access warnings. For each table, decide whether the reported access is intended. If a check could not run, get that check done separately.
- Try the app without signing in. Check pages, search results, shared links, and file downloads. Ask your developer to check direct database requests too; the app’s screens may hide data that the backend still allows.
- Try two ordinary accounts. Use test records to check that one user cannot see, change, or delete the other user’s private data—or create a record in the other user’s name. Test administrator-only actions too.
- Check again after changes. Review warnings from Continuous Sync and retest important permissions when you change roles, sharing, sign-up, files, or database rules.
Only test projects you own or have permission to assess. Keep the results with your live-migration checklist, so the person approving the move can see what was checked.
Technical checks to share with your developer
The automated table check looks for disabled RLS and simple policies such as USING (true) or WITH CHECK (true), alongside the database permissions that allow access. It reports possible access with the public key alone separately from access for signed-in users. Other restrictions can still affect what a request can do.
The check covers the public, core, and migration target schemas. To inspect simple policies in the SQL editor, start with:
select schemaname, tablename, policyname, cmd, roles, qual, with_check
from pg_policies
where schemaname in ('public', 'core')
and permissive = 'PERMISSIVE'
and (qual = 'true' or with_check = 'true')
order by schemaname, tablename, cmd;Add the target schema if your migration uses another one. Tables with no policies do not appear in this query, so check disabled RLS separately. Review table and column permissions, rules that further restrict access, database views, and privileged functions.
For a direct signed-out request to a table in your own project:
curl "https://<project-ref>.supabase.co/rest/v1/<table>?select=*&limit=5" \
-H "apikey: <your public key>"An empty result can mean the table is empty; one denied request does not prove that every operation is protected. Test with representative records and two signed-in users. Review server-side functions, storage policies, and the built frontend for exposed secret keys as separate checks.
Move with a clear picture of your app’s permissions
Staticbot carries your app to a Supabase project you own, keeps Base44 login requirements where it can confirm them, and shows you common signs of open database access. Use that information to make deliberate decisions about what your users can see and do.
Start with the Lovable migration guide or the Base44 migration guide, or start a free test migration.
