Vibe-coded app broken after launch? What to check and what to fix first

In short: an app built with AI tools and no engineer rarely breaks in the interface. It breaks where nobody looks: a database anyone can read, secret keys shipped to the browser, payments that never become orders, no backups and no monitoring. Fix data first, then money, then backups and monitoring. A full rewrite is not always needed: most projects can be rescued in parts.

15 min read

In short

  • Open databases became a pattern in 2026: UpGuard found 16,326 Supabase databases with tables anyone could read.
  • AI-generated code is almost always syntactically valid, yet in Veracode’s 2026 testing it passed security checks in 56–62% of tasks on average.
  • Five typical failures: an open database, secret keys in the browser, “paid” without an order, no backups, no monitoring.
  • Repair order: data the same day, then money, backups and monitoring, and only then code quality.
  • Rewrite only when there is no coherent data model or no access to the infrastructure. Otherwise, rescue.

Why this became a pattern in 2026

Vibe coding means building an app by describing it to an AI: you explain what you need, and a builder such as Lovable, Bolt or Replit writes the code and wires up a database such as Supabase. A working first version in a weekend is a real achievement. The difficulty lies elsewhere. AI reliably builds what is visible on screen, while the invisible parts — access rules, payment verification, backups — get built only when someone asks for them explicitly. A founder without an engineering background has little reason to ask for something that never shows up in a demo. That is not negligence; it is how the tool works.

By late 2026 there were enough published cases to speak of a pattern rather than isolated mistakes.

  • Moltbook, January. Researchers at Wiz found a Supabase key in the JavaScript the site sends to every browser. Row Level Security (RLS) had not been configured, so the key opened the database: about 1.5 million API tokens, about 35,000 email addresses and 4,060 private conversations between agents, some of which contained OpenAI API keys in plain text. The access allowed changing existing posts, not just reading data. By the founder’s own public account, the project was built entirely with AI. The team closed the access within hours of the researchers’ report.
  • An app hosted on Lovable, February. The Register reported a researcher’s findings in a single published app: 16 vulnerabilities, six of them critical, with 18,697 user records at risk. According to the researcher, an access check worked backwards: it blocked signed-in users and let anonymous visitors through. In The Register’s assessment, when a project owner does not explicitly implement Supabase row-level security and role-based access, generated code can look functional while being flawed. Lovable said it acted within minutes of receiving the disclosure and contacted the app’s owner; that every project built with Lovable includes a free security scan before publishing; and that implementing its recommendations is at the user’s discretion. It added that the project included code not generated by Lovable and that the vulnerable database was not hosted by Lovable.
  • UpGuard, fall 2026. In research first reported by TechCrunch on September 25, UpGuard examined about 300,000 domains showing signs of Supabase and found 16,326 databases with readable tables. More than half showed indicators of personal data; a smaller share included passwords or authentication tokens. UpGuard notes that tables created programmatically through the API — the way coding agents work with Supabase — do not get RLS by default. Supabase’s chief information security officer told TechCrunch that projects are “secure by default”, that security is a shared responsibility in which customers control how their own projects are configured, and that Supabase notifies affected customers when it finds issues.
  • Veracode, July and October. Its 2026 GenAI Code Security Report, covering more than 100 models tracked since the program began, found that generated code compiles almost universally yet passes security checks in 56% of tasks on average, ranging from 63% for Python down to 30% for Java. The October update put the average at 62% and the best models at 73%. That is real progress, but even the leaders still fail the security check in more than a quarter of tasks.

Five typical failures

Apps built without an engineer tend to fail in the same places. Here they are, ordered by the damage they cause.

Failure
How it shows up and what it risks
Open database
Tables without RLS can be read and changed with the public key. An outsider can download customers, orders and messages, change prices or delete data. Nothing in the interface shows it, so the owner may not notice.
Secret keys in browser code
A payment provider’s secret key, an AI API key or the Supabase secret key (legacy name: service_role) sits in the JavaScript every visitor downloads. With it, someone can spend your balance or bypass every access rule.
“Paid”, but no order
The “thank you for your payment” page marks the order as paid itself, although the money was never confirmed. Or the reverse: the money arrived, the provider’s notification was lost and the order sits unpaid. A repeated notification creates a second order.
No backups
There are no backups, nobody has ever tested one, or they live next to the database. One wrong command, typed by a person or run by an AI agent “to fix something”, can wipe a table for good.
No monitoring
The owner learns about an outage or failed payments from customers, or from revenue a week later. There are no logs, so it is impossible to reconstruct what happened.

The two kinds of Supabase key are worth understanding. The publishable key (legacy name: anon) is designed to live in the browser — but it is only safe when RLS is enabled on every exposed table and the policies are correct. The secret key bypasses RLS entirely and must never reach a browser. In the Moltbook case, the key in the browser was the public kind; without RLS, it still opened the database. The step-by-step check is in our Supabase RLS security checklist.

A 15-minute self-check, no developer needed

These checks do not replace an audit, but in a quarter of an hour they show whether something is on fire. Run them only on your own app, with your own test accounts.

Go through each item
  • Create two test accounts. Sign in as the second and open the address of an order or profile that belongs to the first, by changing the number or ID in the address bar. If it opens, other users can see each other’s data.
  • Open your site in Chrome, press F12, go to the Sources tab and search across all loaded files (Ctrl+Shift+F, or Cmd+Option+F on a Mac). Search for sb_secret_, sk_live_ and rk_live_. If your project still uses legacy Supabase keys, also search for the last 12 characters of your service_role key, copied from Settings → API Keys in your dashboard: legacy keys all begin the same way, so only the end tells them apart. Any match is a reason to contact an engineer the same day.
  • If your database is on Supabase, open the Security Advisor in the Advisors section of your project dashboard. Any finding that a table is publicly accessible or has RLS disabled is the top risk.
  • Reconcile the money: count payments over the last 30 days in your payment provider’s dashboard and paid orders in your admin panel. Any mismatch is not a rounding issue; it is a symptom.
  • Make a test purchase for the smallest amount and close the tab right after paying, without waiting for the “thank you” page. Check whether the order became paid.
  • Find the latest backup: where it is stored, how old it is, and whether anyone has ever restored it. “The hosting probably does that” means no. On the Supabase Free plan, for example, Supabase recommends exporting your data yourself on a regular basis.
  • Ask yourself: if the site goes down at 3 a.m., who finds out and how? If the answer is “customers, in the morning”, there is no monitoring.
  • Check whose name is on the domain, the hosting, the Supabase and builder accounts, the code repository and the payment account. All of them should be under a company email, not a contractor’s.

What to fix first

The order is set not by how hard the work is, but by where the damage grows every hour. Clean code and new features wait until the first four items are done.

Repair order
  1. 01

    Data — the same day

    Enable RLS on every exposed table and write policies along the lines of “a user sees only their own rows”. Rotate every secret key that has ever been in the browser or in the repository. Move secret operations from the browser to the server. Review the access logs.

  2. 02

    Money — in the first week

    Only the server sets an order to “paid”, and only after the payment provider confirms it; the browser never does. A repeated notification about the same payment does not create a second order. A daily automatic reconciliation against the provider’s records. How this works is explained in our article on payment idempotency.

  3. 03

    Backups — right after money

    Daily backups to separate storage and a test restore onto a clean environment. A backup that has never been restored is a hope, not a backup.

  4. 04

    Monitoring

    An uptime check every minute, alerts on errors and failed payments sent to a channel you actually read, and logs good enough to reconstruct any incident.

  5. 05

    Access and documentation

    All accounts move to the company, passwords go into a password manager, and a short document appears: where everything lives and how changes are deployed.

  6. 06

    Only then — code quality

    Tests for the critical flows, cleaning up duplicated code, new features. Now the money is well spent, because the foundation no longer leaks.

Rewrite or rescue

The urge to “tear it down and build it properly” is understandable, but it is usually expensive and often unnecessary. A rewrite puts you back at the start: the old bugs are gone, the new ones have not been found yet, and the business waits for months. The decision should rest on facts from an audit. We cover the criteria in detail in rescue or rewrite an AI-built app.

Situation
Better option
The data structure makes sense; the holes are in access rules and integrations
Rescue: close the vulnerabilities, fix payments, add backups and monitoring
The app works, but every change breaks something next to it
Rescue in parts: tests on critical flows first, then rewrite module by module
No real data model: the same thing is stored in five places
Rewrite the core, keeping the interface and customer data
No access to the code, database or accounts, and the contractor is gone
Recover access first; if that is impossible, rebuild using the live product as the specification
The builder will not export the code, or you need more than its limits allow
Move to your own infrastructure, using the current version as a prototype

The good news is that vibe coding has already done its job: the product exists, its flows have been tested on real people, and it is clear what customers want. Finding a product people need is the hardest part, and it is behind you. The engineering work that follows is finite and can be estimated.

How we take on a project like this

We start with a 5-day diagnosis, described on the project rescue page. We check the code, database, keys, payments, backups and access, and deliver a written plan: what to close today, what within a month, what can be left alone, and what each part costs. In 2026 the diagnosis costs $1,500–3,500 and takes one week; every other range is on the pricing page. Our engineering team works from Tashkent, inside your accounts. If you are choosing between teams, our guide on hiring someone to fix an AI-built app lists what to ask any of them, including us.

  • The contract fixes the price and the deadline. For each day of delay the invoice drops by 2%, capped at 10%.
  • You see a working version every two weeks, not only at the end.
  • Your own engineer can review the code. If they find a contract item that was not delivered, we refund 10%.
  • The rights to the source code and data pass to you once it is paid for, and the domain and service accounts are in your name.
  • Bugs in our work are fixed free of charge for the lifetime of the product.

Once the app is stable, you can keep it with us on support: monitoring, updates and improvements as the product grows.

Frequently asked questions

Is vibe coding a bad idea?

No. It is a fast way to test an idea on real people. Problems start when a prototype that never had a security and payments review becomes the main product and starts handling money and customers’ personal data.

How do I know if my app’s database is exposed?

The simplest sign of an access problem is a second test account seeing the first account’s data after you change the ID in the address bar. If your database is on Supabase, the Security Advisor in the dashboard flags tables without RLS. A definitive answer needs an audit, which checks every table and every query, not just the visible screens.

Is the Supabase public key in my site’s code a leak?

Not by itself: the publishable (anon) key is designed for the browser. It becomes a problem when RLS is off or the policies are wrong, because then that key opens the data. A secret or service_role key in the browser is always a leak and must be rotated.

What does an audit cost and what do I get?

Our diagnosis costs $1,500–3,500 in 2026 and takes one week, of which the review itself is 5 working days. You get a written report: vulnerabilities ranked by risk, the state of payments, backups and access, a plan with price and timeline, and a recommendation on whether to rescue or rewrite.

Can we keep building with AI after the repair?

Yes, as long as changes go through checks: tests on critical flows, an engineer’s review before release and monitoring after. AI speeds up the work, but access rules and payment logic need a human reviewer.

The contractor disappeared along with the credentials. Where do we start?

With a list: domain, hosting, database, repository, builder account, payment account, app stores. For each one, note whose name it is in and how to recover it. Recovering access is part of our diagnosis; if something cannot be recovered, the plan accounts for that from the start.

Sources

Every claim here can be checked: below are the primary sources, not a retelling.

  1. 01Wiz: Hacking Moltbook — exposed database reveals millions of API keys — Published February 2, 2026, reported to Moltbook on January 31: Supabase publishable key in client JavaScript, no RLS, 1.5M API tokens, ~35,000 emails, 4,060 agent conversations, write access, fixed within hours
  2. 02The Register: AI-built app on Lovable exposed 18K users, researcher claims — February 27, 2026: 16 vulnerabilities, 6 critical, 18,697 records; Lovable’s response
  3. 03UpGuard: Everything, everywhere — systemic data exposure in Supabase apps — Page dated October 14, 2026: ~300,000 domains, 16,326 databases with readable tables, API-created tables without RLS by default
  4. 04TechCrunch: Some Supabase customers are publicly exposing reams of people’s data to the web — September 25, 2026: first report of the UpGuard findings; Supabase’s response
  5. 05BleepingComputer: Over 16,000 Supabase databases expose PII, passwords, auth tokens — September 28, 2026: methodology and personal data share
  6. 06Veracode: LLMs are getting smarter, but not safer — 2026 GenAI Code Security Report — July 28, 2026: 56% average, ~100% syntax pass rate, Python 63%, Java 30%
  7. 07Veracode: First meaningful gain in AI code security since 2025 as average pass rate hits 62% — October 29, 2026: 62% average, best models 73%
  8. 08Supabase docs: Understanding API keys — Publishable vs secret keys; secret keys bypass RLS
  9. 09Supabase docs: Database backups — Daily backups on paid plans; Free plan projects advised to export data regularly
  10. 10Stripe docs: API keys — Live secret and restricted keys start with sk_live_ and rk_live_; only publishable keys are safe to expose
dbit.one engineering desk
The engineers who build these systems

These articles are written by engineers working on the projects and published under the desk’s name. The studio and the desk’s published rules stand behind every text, not a single author; articles about our own open-source code carry the author’s name.

How we write and what we verify

Related services

Read next

Choices & process15 min read

Supabase security checklist: check RLS, keys and storage in your own app

In short: in a Supabase app, the browser talks to the database directly, and Row Level Security (RLS) is the only thing deciding who sees which rows. Check four things in your own project: RLS is on for every exposed table, the policies limit users to their own data, no secret key ships to the browser, and storage buckets are not public by accident. The Security Advisor in the dashboard catches most of it. If a secret key leaked, fix the cause, then rotate.

Choices & process9 min read

Rescue or rewrite an AI-built app: how to decide, and what to fix in what order

In short: most AI-built apps are cheaper to rescue in parts than to rewrite. A rewrite is justified when the data model is incoherent, when you cannot get access to your own code and infrastructure, or when the platform cannot support where the business is going. Decide on audit findings, not frustration, and fix in order of damage: data, money, backups, monitoring, then code.

Choices & process11 min read

How to hire someone to fix your AI-built app without losing control of it

In short: before anyone touches your app, make sure the code, database, domain and payment accounts are in your name. Give each person the narrowest role that lets them work, never your own passwords. Start with a fixed-price diagnosis that delivers a written, ranked list of problems and a plan with prices. Be wary of proposals that promise a rewrite or a timeline before anyone has looked at the code.

Questions about your project?

Describe your task — within 24 hours we’ll come back with an estimate, timeline and plan.

hello@dbit.one