App Development

Your vibe-coded app is broken. Here is how to hire someone to fix it.

Built an app with Lovable, Bolt or Replit and got stuck? What breaks, what a real audit checks, what the market charges, and how to hire safely.

Duraan AliUpdated 17 min read
Hands untangling a dense knot of glowing fiber-optic cables, one cable already running straight

You described an app to Lovable, Bolt, Replit, Cursor or v0, and something real came out. Screens. A login. A database, maybe a Stripe button. Then it stalled, and now you are searching for someone to finish it. This article is the honest version of what you will find: what is probably wrong, what a real audit checks, what the market charges with sources, and how to hire without handing your users’ data or your app to the wrong person.

I run a web and app studio in Edina, Minnesota, and since early 2025 a growing share of the apps that come through the door were started by an AI tool rather than a person. The pattern is consistent enough that I can usually tell you what is wrong with yours before I have seen it.

What is a vibe-coded app?

It is an app built mostly by describing what you want and accepting what the AI generates, rather than writing the code yourself. The term came out of 2025 and stuck. The platforms themselves say who is building this way: Vercel’s blog on vibe coding, published September 18, 2025, says “about 63 percent of users exploring vibe tools are non-developers,” and Lovable’s June 2026 “build economy” report, as covered by The Next Web, says 80 percent of its builders self-identify as non-technical. Both figures are self-reported by companies selling the tools, but they match what I see. The person who built the app usually cannot read it, and the business behind it is usually early: Redwerk’s 2026 vibe coding report, with 14,300 respondents, found 60.5 percent of builders not yet earning from what they made.

That is not a criticism of the builder. The tools are genuinely remarkable at the first 80 percent of an app. The problem is that the last 20 percent is where the risk lives, and the AI does not know what it does not know.

Why does my vibe-coded app break in production?

Almost every rescue I see has the same handful of problems. They are worth knowing by name so you can ask about them.

An open database. Most of these apps run on Supabase or Firebase. Supabase relies on row-level security, RLS, which is a set of per-table rules deciding which rows each user may read or write. Supabase’s own documentation, read in November 2026, says a table in an exposed schema without RLS “is readable and writable by any role with a grant on it,” and the key that lets the browser talk to the database is, by design, visible in the page’s JavaScript. If the rules are off or wrong, the result is a database any visitor can read.

The numbers on this are not small. Reeve’s passive scan of 30,998 live apps built with Lovable, Bolt, v0, Replit and Base44, run August 12 to 14, 2026 and published August 19 (summarized in vibe-eval’s August 2026 security digest), found that 57 percent of the reachable Supabase-backed apps it could check, 2,096 of 3,680, allowed unauthenticated table reads. Symbiotic Security’s scan of 1,072 Supabase-backed vibe-coded apps, published June 2, 2026, found at least one security issue in 98 percent of them, at least one critical issue in 16 percent, and 39 sites that exposed their entire database for reading to anyone with the public key. Both are vendor studies that count detected markers rather than confirmed breaches, and the denominators are narrow, but the direction is unambiguous.

A Lovable-specific version of the missing-rules problem became CVE-2025-48757, published May 30, 2025 with a CVSS 3.1 score of 9.3. Researcher Matt Palmer’s statement of May 29, 2025 reported 170 of 1,645 Lovable projects he analyzed, about 10 percent, with inadequate RLS across 303 endpoints. Lovable shipped a security scan on April 24, 2025 that checked whether RLS policies existed; Palmer’s criticism was that it did not check whether they were correct, which is the harder question and still the one that matters.

Secrets in the browser. There are two kinds of keys. The publishable key, formerly called the anon key, is designed to be public. The secret key, formerly service_role, bypasses every row-level security policy. Supabase’s documentation says to “never put one in a browser, a shipped application, or source control,” and that the legacy anon and service_role JWTs are being deprecated by the end of 2026. AI tools regularly put the second kind of key where the first belongs, or commit it to the repository where it stays in the history after someone deletes it from the file.

Auth that is theater. A login screen exists, and the routes behind it never check who is asking. A user who changes the ID in the URL sees another user’s record. The security vocabulary for this is broken object-level authorization, and it is the most common serious finding in audits of AI-built apps because the AI built the screen you asked for and nothing you did not.

Works in preview, breaks in production. The preview environment runs same-origin and forgiving. Deployment surfaces CORS errors, environment variables that were never set in production, payment keys that only ever existed in test mode, and on some platforms the discovery that development and production data were never the same database.

No tests, no error handling. Every new prompt risks quietly breaking something that used to work, and nothing tells you. The app fails silently, the user sees a spinner, and the error goes nowhere because no logging was ever set up.

Database performance. Queries that were fine with ten rows of seed data become N+1 patterns and full table scans with a thousand real users, because the AI never saw a thousand real users.

None of this is unique to AI. Veracode’s 2025 GenAI Code Security Report, published July 30, 2025, ran 80 coding tasks across more than 100 language models and found that in 45 percent of test cases the model introduced a vulnerability in an OWASP Top 10 category, over 70 percent for Java, and that models failed to protect against cross-site scripting in 86 percent of the relevant cases. Human developers write insecure code too. The difference is that a human developer usually knows which parts they are unsure about. The AI is equally confident everywhere.

What is wrong What you notice What the fix usually is
RLS missing or wrong Nothing, until someone tells you they can see other people’s data Policies written per table, read and write separately, grants revoked, verified with a test user
Secret key in the client Nothing, until it is used against you Key moved server-side, old key rotated, repository history scrubbed
Routes not protected Changing an ID in the URL shows someone else’s record Server-side checks on every protected route, not just a hidden menu item
Preview and production differ “It worked yesterday” Separate environment variables, CORS configured, live payment keys and webhooks set
No tests or logging Features that were “done” break again Error tracking, a handful of tests on the money paths, a staging environment
Slow with real data Pages that took a second now take ten Indexes, query rewrites, pagination

Should I fix it or rebuild it?

Fix, usually. If the AI picked a reasonable stack, and React with Supabase or Next.js with a managed backend is a reasonable stack, a developer can repair the implementation and keep what is structurally sound. A rewrite is warranted only when the architecture genuinely cannot carry real users: no separation between tenants, a data model that will not survive the next feature, business logic scattered through the front end with nothing on the server.

The rule that protects you: a quote to rewrite everything from someone who has not read your code is a warning sign. The right first purchase is an audit, not a rebuild.

What does a proper audit actually check?

A short, paid review of the code, the database rules, the authentication, and the deployed app rather than the preview. Wavect’s June 2026 write-up on audit cost puts the initial audit at “a few focused days to roughly a week” for an app with accessible source and a bounded architecture, and that matches my experience. The deliverable is a written list of findings ranked by risk, with evidence, so you can hand it to anyone. You keep that document whether or not you hire the person who wrote it, which also makes it the best tool you have for comparing quotes.

This is what the list should cover. If a proposed audit skips most of it, it is a sales call with a fee.

Area What good looks like What the AI usually left
Row-level security RLS enabled on every exposed table, with separate read, insert, update and delete policies tied to the signed-in user, tested with a second account RLS off, or a single permissive policy that allows everything
Keys and secrets Only the publishable key in the browser; secret key, payment keys and API keys in server environment variables; none in Git history Secret key in the client bundle or committed, often in a file deleted later but still in history
Authentication Sessions handled by the platform, protected routes checked on the server, password reset and email verification working, roles enforced in the database rather than the menu A login page guarding a client-side redirect
Authorization Every record fetch scoped to the current user or organization Fetch by ID with no owner check
Payments Live-mode keys, a webhook endpoint that verifies Stripe’s signature, handles duplicate events and records what it did; Stripe’s documentation says the signing secret differs between test and live and that it retries failed deliveries for up to three days Checkout in test mode, no webhook, order marked paid in the browser
Rate limits and abuse Limits on login, signup, contact and any endpoint that sends email or costs money None
Data and backups Point-in-time recovery or scheduled backups on the database, one restore tested, a migration history Schema edited by hand in the dashboard, no migrations
Error handling and logging Errors captured somewhere a person reads, user-facing messages that do not leak internals Silent failures, stack traces in the UI
Tests A handful of tests on the paths that touch money and data None
Dependencies Known-vulnerable packages updated A year-old lockfile
Deployment Separate preview and production environments, custom domain with a certificate, CORS limited to your origins One environment, wildcard CORS
Data model Tables and relationships that will survive the next three features Duplicated fields, JSON blobs where tables should be

Two notes on the tools’ own scanners. Lovable’s documentation, read in November 2026, describes a quick scan that runs automatically when you open the publish dialog and covers database rules, dependency vulnerabilities and exposed MCP servers, plus a deeper on-demand scan that reviews application code for access control, injection, leaked secrets and payment logic. It also says plainly that these scans “do not replace a thorough security review” and that you remain responsible for your app’s security. Run them. Then get a person to read the code, because a scanner can see that a policy exists and cannot judge whether it enforces your business rules.

Three questions to ask before paying for any audit:

  1. Will you look at the code before you quote the fix? If no, walk away.
  2. Do you work in the stack the AI chose, or will you move me to yours?
  3. What will I own at the end, and will you put that in writing?

What does it cost to fix a vibe-coded app?

The market is wide, and the spread tells you something. Every figure below is a published third-party price with the date I read it. TayoPro’s own number is a fixed price against a written scope, quoted after the audit, and it is not in this table.

Tier Published price Source and date What you get
Marketplace gigs $15 to $305 Fiverr “Vibe Coding” category, read October 2026 A listing. Some are good; the listing cannot tell you which
Fixed-fee human audit $199 to $1,499 (Valletta Software); $1,000 (RapidDevelopers) As listed in Justin McKelvey’s audit-cost roundup, November 3, 2026 A senior engineer reading the code for a few days, with a prioritized fix list
Specialist rescue tiers $5,000 to $28,000 OneZero’s published tiers, cited in Devox’s 2026 rescue-company roundup, read October 2026 Audit, fix, harden, hand off
UK agency bands £5,000 for light stabilisation; £15,000 to £40,000 for a substantive backend rebuild Rocking Tech, May 12, 2026 Structural refactor over two to eight weeks
Full rescue, larger apps $15,000 to $100,000 McKelvey roundup, November 2026 Weeks of engineering on an app with real users

Upwork and Fiverr profiles now advertise “shipping the last 20 percent” of Lovable, Bolt, Replit and Base44 apps, and some of those people are excellent. The failure mode at the bottom of the market is not a bad button. It is a database full of your users’ data that anyone can read, fixed by someone who did not know to look.

Where your app sits in that spread depends on three things: whether the security problems are configuration, which is cheap to fix, or architecture, which is not; how much of the app works versus merely looks like it works; and how much is still unbuilt. The audit is what tells you. For what software costs when built from scratch, our breakdown of what it costs to build an app covers the market ranges with sources, and the pricing page collects the published benchmarks.

How do I find someone to finish my AI-built app?

Search for the phrases the market actually uses, “vibe coding cleanup,” “vibe coding rescue,” “fix my Lovable app,” “take over AI-generated codebase,” and you will find three kinds of provider.

Marketplace freelancers. Cheapest, fastest to start, widest variance. Vet by asking for a sample audit report and by asking exactly how they handle RLS and secret keys. If the answer is vague, so is their security review.

Agencies with a new landing page. Many offshore and some domestic shops added a rescue page in 2025 and 2026. Some have deep production experience; some have a page. Ask who will do the work, whether they will stay in your stack, and for a reference from a rescue, not from a greenfield build.

Local studios that have always built production apps. Usually the most expensive per hour and the cheapest per fixed problem, because they have already made the mistakes the AI is making. Ask the same questions; proximity is not a credential.

Whichever you choose, vet them on the audit, not the pitch. Ask to see a redacted findings document from a previous rescue. Ask them to explain, in plain words, the difference between the publishable key and the secret key and where each belongs. Ask what they would do if they found a customer’s data exposed on day one (the right answer involves telling you immediately, rotating keys and fixing policies before anything else). Ask to be invited into your hosting, database and payment accounts as a collaborator rather than handing over passwords; a good developer asks for that themselves.

What does a fair engagement look like?

The shape that protects both sides is the same whether the developer is a freelancer or a studio.

  1. A paid audit with a fixed price and a written deliverable. A few days of work. You receive the findings ranked by risk, with evidence, in a document you own.
  2. A fixed scope built from the audit. Each finding becomes a line item: fix, defer, or accept. The scope says what “done” means for each one, for example “a signed-out user receives no rows from any table; verified with the attached test script.”
  3. A fixed price against that scope, with milestones if the work runs more than a couple of weeks. Hourly open-ended work on a rescue rewards the developer for the app staying broken.
  4. A staging environment where fixes are tested against a copy of real data before they touch production.
  5. A handoff covering everything in the next section, plus a short written guide to what is now safe for you to change with prompts and what should go to a person.
  6. An optional maintenance arrangement afterward, at a fixed monthly price, for the updates, monitoring and small changes that any live app needs. Decline it if you do not need it, but ask what it covers, because an app with real users and real payments does not maintain itself any more than a website does.

Anything structured as “pay a retainer and we will see” is not a rescue. It is a subscription to uncertainty.

What should I hand over, and how?

Give access, not passwords. Every platform involved supports inviting a collaborator, and the invitation can be revoked the day the work ends.

  • The repository. If the AI tool is connected to GitHub, add the developer to that repository. If it is not, ask the tool to export or sync the code to a repository you create in your own account first, then invite them.
  • The database. Invite them to the Supabase or Firebase project as a member. Do not send the secret key in an email.
  • Hosting. Vercel, Netlify, Render or the tool’s own hosting: add a team member.
  • Payments. Add them to your Stripe account as a team member with developer permissions, or create a restricted key scoped to what they need. Never share your live secret key.
  • The domain. Delegate access at the registrar rather than sharing the login, and confirm the domain is registered to your organization, not to the tool or to a freelancer.
  • Context. The prompt history or project chat, a list of what works and what does not, who the users are, what data is sensitive, and any test accounts.

When the work is done, remove the invitations and rotate every key: database, payments, email provider, any third-party API. A developer who objects to rotation is telling you something.

What are the red flags?

  • A fixed quote to rebuild before anyone has read the code.
  • A security review described in generalities, with no mention of row-level security, keys or authorization by name.
  • Insistence on moving you to their preferred stack as a precondition.
  • A request for your passwords or your live payment key instead of an invitation.
  • No written findings, or findings you are not allowed to keep.
  • Code to be held in their repository until final payment, rather than yours from day one.
  • A retainer with no scope.
  • Silence about ownership when you ask what you will own at the end.
  • Refusal to leave the AI tool connected so you can keep building.

Will I still own my app, and can I keep vibe coding?

You should own it, and you should be able to keep building on it. A developer who does this well leaves you with a Git repository in your account, the AI tool’s sync connected to it, separate preview and production environments with their own variables, error monitoring that emails you, a tested backup, and one page in plain language saying where everything lives and what is safe to change with prompts. The goal is to make you more independent, not to make you a client forever.

Keep vibe coding the parts that are safe to vibe code: copy, layouts, new screens that read data the policies already protect. Send the parts that are not to a person: anything that touches authentication, payments, permissions or the data model. That split is the difference between a founder who ships every week and one who re-prompts the same bug every week.

When should you stop vibe coding and hire someone?

If you recognize more than two of these, you are there.

  • More of your week goes to fixing regressions and re-prompting the AI to repair its own work than to building anything new.
  • You have real users, real payments, or anyone’s personal data in the app.
  • The deployed version behaves differently from the preview and you do not know why.
  • You cannot confidently answer “can a stranger read my database?”
  • You have a feature the AI has “finished” three times.
  • Someone has asked you for a privacy policy, a security questionnaire or a data processing agreement and you do not know what to write.

That last 20 percent is finishable. It just needs a person who has done it before.

What to do next

Run your tool’s built-in security scan today, then open the deployed app in a private window and try to reach a page you should not be able to see. Write down what you find. Then get a paid audit from someone who will read the code before quoting the fix, and keep the findings document whatever you decide.

If you want that audit from us, tell us about your app and we will start there, with a fixed price for the audit and a fixed price against a written scope for whatever it finds. TayoPro does vibe coding cleanup and AI app rescue and builds web applications from scratch, and the same studio designs and builds websites and keeps them maintained month to month, both at a fixed price quoted in writing. We will tell you plainly if your app needs none of it.

FAQ

Questions people ask about this

What is a vibe-coded app?

An app built mostly by describing what you want to an AI tool such as Lovable, Bolt.new, Replit, Cursor, v0 or Base44 and accepting what it generates, rather than writing the code yourself. The term came out of 2025 and stuck. Most such apps run a React or Next.js front end on top of Supabase or Firebase, and most of the people who built them cannot read the code, which the platforms confirm: Vercel's September 2025 blog put non-developers at about 63 percent of vibe-tool users, and Lovable's June 2026 report said 80 percent of its builders identify as non-technical.

Why does my vibe-coded app work in preview but break when deployed?

Previews run in a forgiving, same-origin environment. Deployment exposes CORS rules, environment variables that were never set in production, payment keys that only existed in test mode, and routes that were never actually protected. Several tools also keep development and production data in different places, so what worked on your screen never touched the real database. An audit of the deployed app, not the preview, is how you find out which of these you have.

Should I fix my AI-built app or start over?

Usually fix. If the AI picked a reasonable stack, and React with Supabase or Next.js with a managed backend is a reasonable stack, a developer can repair the implementation and keep what is structurally sound. A rewrite is warranted only when the architecture cannot safely carry real users, for example no separation between customers' data or a data model that will not survive the next feature. You should learn that from an audit, not from a sales pitch.

How much does it cost to fix a vibe-coded app?

The published market is wide. Fiverr's vibe-coding category listed gigs from about $15 to $305 when we read it in October 2026. Fixed-fee human audits are listed at $199 to $1,499 and $1,000 by two firms in Justin McKelvey's November 2026 roundup, and OneZero publishes rescue tiers of $5,000 to $28,000. Most specialist firms quote only after an audit, and so do we. TayoPro quotes a fixed price against a written scope once the audit says what the scope is.

Can I keep vibe coding after a developer fixes it?

Yes, if the developer sets it up that way: a normal Git repository you own, the AI tool's export or sync connected to it, environment variables separated for preview and production, and a short written guide on what is safe to change with prompts and what to send to a person. Ask for that explicitly before you hire anyone, and make it an acceptance criterion.

Is it safe to launch my Lovable or Bolt app to real users?

Not until three things have been checked on the deployed app: that row-level security is enabled with correct read and write policies on every exposed table, that no secret or service-role key is in the browser bundle or the Git history, and that every protected route checks who is asking on the server. Lovable's own documentation says its built-in scans do not replace a thorough security review, and most AI-built apps fail at least one of those three on first inspection.

Keep reading

Start a project

Ready to take your business to the next level?

Let's work together to create solutions that make a real impact. Tell us about your project and we'll come back with a clear plan.

(612) 293-0636info@tayopro.com