An app built with AI tools like Lovable, Replit, Bolt or Cursor can go from idea to working demo in days. Taking it to production, with real users and real money, means checking six things those tools don't guarantee: secrets, database permissions, payments and webhooks, forms and email, error monitoring, and code maintainability. This checklist covers what to verify in each area before you launch, and the signs that it's time for an outside review. If you'd rather have us check it, see our AI-built app audit.

Prototype vs. production: what changes

AI coding tools are optimized to make the demo work: the screen looks right and the main flow does what you asked. A production app also has to behave when things go wrong, like a declined card, a user poking at someone else's data, an email that never arrives, or an outage at 2 a.m.

PrototypeProduction
Works with your test dataWorks with thousands of users and real data
One user: youEvery user sees only their own data
Payments in test modeReal charges, refunds and failures
Errors show up on your screenErrors show up in alerts, not in an angry customer email
Code understood by the AI that wrote itCode a human developer has to maintain

1. Secrets and API keys

This is the most common issue, and the most expensive one. API keys for services like OpenAI, Stripe or your email provider sometimes end up in code shipped to the browser, or committed to the repository.

  • Search your frontend code for keys. Anything the browser downloads, anyone can read.
  • Move secret keys server-side (backend functions or edge functions) and store them as environment variables.
  • Know which keys are public and which are secret. Some are designed for the browser; others must never be there.
  • Rotate any key that was ever exposed. Deleting it from the code isn't enough, because it may still be in your git history.

2. Database access rules

Many AI-built apps run on Supabase or Firebase. Both let the browser talk directly to the database, so they rely on access rules: Row Level Security (RLS) in Supabase, Security Rules in Firebase. With rules missing or too permissive, any signed-in user can read or edit other users' data.

  • Confirm that every table with user data has rules enabled.
  • Test with two accounts: account A must not be able to read or change anything that belongs to account B.
  • Review admin roles: who can see everything, and how is that role granted?

3. Payments and webhooks

Charging looks simple until something fails. Stripe and other providers tell your app what happened (payment succeeded, failed, refunded) through webhooks. Common mistakes:

  • Not verifying the webhook signature, so anyone could send a fake "payment succeeded" event.
  • Processing the same event twice. Providers retry deliveries; without idempotency, one payment can fulfill two orders.
  • Relying on the "thank you" page instead of the webhook to grant access.
  • Ignoring failed payments, renewals and subscription cancellations.

4. Forms, email and backups

  • Emails that don't arrive. Signup, password reset and notifications need a transactional email provider and a properly configured domain (SPF, DKIM), or they land in spam.
  • Forms that fail silently. If a submission fails, the user should know, and so should you.
  • Server-side validation. Browser-side validation can be bypassed.
  • Backups. Confirm they exist, how often they run, and that you know how to restore one.

5. Error monitoring

In production, nobody is watching the screen. You need to hear about errors before your customers do:

  • Error tracking on frontend and backend (for example, Sentry).
  • Logs for critical actions: payments, signups, data changes.
  • Alerts by email or chat when something critical breaks.
  • Uptime monitoring so you know when the app is down.

6. Maintainability and tests

AI-generated code tends to duplicate logic and grow without structure, because each prompt is solved on its own. It works, but every change gets riskier and slower. You don't need a rewrite:

  • Find the hotspots: the parts that change most often and the ones that handle money or personal data.
  • Add tests to the critical flows (signup, checkout, the core action) so a change can't silently break them.
  • Consolidate duplicated logic in those hotspots.
  • Document the basics: how to install it, which environment variables it needs, and how to deploy.

7. Performance and infrastructure costs

An app that runs fine with ten users can get slow or expensive with a thousand. Before launch, check:

  • Database queries: screens that load long lists should paginate and use indexes instead of pulling whole tables.
  • AI model calls: if the app calls AI APIs, set per-user limits and watch spend. A malicious user or a bug in a loop can run up the bill fast.
  • Rate limiting on signup, login and forms to slow down abuse and bots.
  • Billing alerts on every provider (hosting, database, AI, email) so a spike doesn't surprise you at the end of the month.
  • A privacy policy and terms of service that explain what data you store and why.
  • Data minimization: store only what the app needs.
  • Account deletion: users should be able to ask for their data to be deleted.
  • Vendors: know where your providers store data and what they do with it, especially if you have users in the EU or California.

How an audit works

  1. Scope: you share the repository, the stack and what the app must do. We agree on a fixed scope and price.
  2. Review: we review code, configuration and critical flows: authentication, payments, data and integrations.
  3. Risk map: you get a prioritized, plain-English report: what's risky, why it matters and how to fix it.
  4. Fix or hand off: we fix the critical items for you, or hand off a plan your developer can follow.

Most audits take one to two weeks, depending on the size of the codebase and the number of critical flows.

A note on vibe coding

"Vibe coding" — describing what you want and letting an AI write the code — is a great way to validate an idea quickly. The problem isn't the method; it's shipping the prototype as if it were the product. Treat the AI-built version as a strong first draft: keep what works, review what handles money and data, and add the guardrails a real product needs.

Pre-launch checklist

  • ☐ No secret keys in the frontend or the repository
  • ☐ Any previously exposed keys rotated
  • ☐ Database access rules (RLS or Security Rules) enabled and tested with two accounts
  • ☐ Payment webhooks verify signatures and are idempotent
  • ☐ Failed payments, refunds and cancellations handled
  • ☐ Email sent through a transactional provider with SPF and DKIM
  • ☐ Server-side validation on all inputs
  • ☐ Backups running and tested
  • ☐ Error tracking and alerts in place
  • ☐ Tests on critical flows
  • ☐ Minimal documentation for the next developer

When to get an audit

  • You're about to launch to paying customers or handle personal data.
  • You're presenting the app to investors or partners.
  • Every change breaks something that used to work.
  • You're hiring a developer and want them to know where to start.
  • You're not sure whether the checklist items are actually covered.

An audit doesn't mean a rewrite. The goal is to find what's risky, fix it in priority order, and keep what works.

Launch with confidence

We review your repository and deliver a prioritized risk map and, if you want, the fixes themselves. See our AI-built app audit or contact us.