AuditAI-built app security and production readiness

A security audit for the app your AI built. It works. Users are signing up. Nobody has read the code.

You shipped with Lovable, Base44, Bolt, Replit, v0, Cursor or Claude Code. The product is real and so are the users. We read the code, the configuration and the database rules, test what a signed-in stranger can reach, and hand you a prioritized report with fixes your AI tool can apply. Then we retest.

  • Read-only access, NDA on request
  • Testing only with your written authorization
  • Fixed scope, written proposal after a short call

audit-report.md

Illustrative example

Findings, ranked by severity

  • DATA-01CriticalDatabase secret key found in the JavaScript bundle
  • AUTH-02HighAny signed-in user can read another customer's invoices
  • HOOK-01HighPayment webhook accepts events without a signature check
  • LLM-01MediumSupport agent runs the refund tool on a pasted instruction
  • COST-01MediumNo rate limit on the AI endpoint, so one script can run up the bill

Every finding comes with steps to reproduce it, the risk, the fix, and a prompt your AI tool can apply. These rows are an illustrative example, not a client's report.

The short answer

An AI-built app security audit is a fixed-scope, human review of an app that was written mostly by AI coding tools. We read the code and the configuration, check who can read and change which data, look for secrets in the client bundle, test the LLM features, and run a light load test. You get a written report: findings ranked by severity, steps to reproduce each one, fix guidance that includes prompts or diffs your AI tool can apply, and a retest after you fix. The work is done by Shai Truchman and a team of experts, and only with the owner's written authorization. There is no price on this page: you get a written proposal after a short scoping call.

01Why this happens

AI tools are graded on the preview. Security is everything the preview does not show.

A coding tool succeeds when the screen works. Authorization, key handling and rate limits do not appear on a screen. They appear when a stranger signs up and starts changing IDs in the address bar.

Four moments when founders find out

  • A user gets curious

    Someone changes a number in the URL and sees another customer's invoice. They can tell you, or they can post it.

  • The first big customer

    Procurement sends a security questionnaire, and the deal waits for answers you do not have.

  • Launch day

    The preview handled one user. Five hundred arrive in an hour and the home page returns an error.

  • The invoice

    Nobody broke in. A script found an AI endpoint with no limit and called it all night.

02Failure patterns

Eight ways vibe-coded apps leak, and where each one lives

None of these is exotic. They are the defaults that fast builds leave behind. The numbers on the map match the list.

The attack surface of an AI-built appA diagram of where an AI-built app is exposed. Traffic from the internet reaches the browser bundle, then the API routes and server functions, which reach the database rules, file storage, webhooks, and the LLM and agent tools. A dashed line shows that on backends like Supabase and Firebase the browser also talks to the database directly. Eight numbered points match the list next to the figure: secret keys in the bundle, missing server-side authorization, database rules, storage buckets, CORS, webhook verification, rate limiting, and LLM features.Internet: users, bots, attackersBrowser bundlekeys and logic anyone can readAPI routes and server functionsauthorization, validation, limitsDatabase rulesRLS, tenant isolationFile storagepublic buckets, uploadsWebhookssignatures, replaysLLM and agent toolsinjection, tool scope12346857
The attack surface of an AI-built app. The dashed line is the browser talking to the database directly, which is how Supabase and Firebase apps work.
  1. Secret keys in the client bundle

    Everything you ship to the browser is readable in dev tools. AI tools reach for whichever key makes the call work, and sometimes that is the admin key. Supabase is blunt about it: A secret key bypasses every Row Level Security policy you have. The same goes for payment and LLM keys. (Supabase docs, API keys)

  2. Missing server-side authorization (IDOR)

    The delete button is hidden from non-admins, but the route behind it never checks who is calling. Or it checks that someone is logged in, not that the record is theirs. Change the ID, get another user's data. This is Broken Access Control, the first category in the OWASP Top 10:2025.

  3. Row Level Security off, or on with a rule that allows everything

    On Supabase the browser talks to the database directly, so the rules are the only wall. The guidance is one line: Enable RLS on every table in an exposed schema. A policy of using (true) turns RLS on and protection off. Firebase has the same trap in test mode, where anyone who guesses your project ID can steal, modify, or delete the data. (Supabase docs, RLS; Firebase docs, insecure rules)

  4. Open storage buckets

    Uploads go to a public bucket because that made the image show up. In a public bucket, anyone who possesses the asset URL can readily access the file. Fine for avatars. Not fine for ID scans, contracts and exports. (Supabase docs, storage buckets)

  5. Permissive CORS

    A CORS error during development gets fixed the fastest way: allow every origin. With cookies involved, browsers refuse a plain wildcard, so generated code often echoes back whatever origin asks, and any website can then act as your logged-in user. (MDN, CORS and credentialed requests)

  6. Unverified webhooks

    The payment webhook marks an order as paid, and it trusts any POST that looks right. Stripe's own warning: Without verification, an attacker could send fake webhook events to your endpoint to trigger actions like fulfilling orders, granting account access, or modifying records. (Stripe docs, webhooks)

  7. No rate limiting

    Login, sign-up, password reset, anything that sends an email or an SMS, and every endpoint that calls a model. Without a limit, passwords can be guessed, inboxes flooded and your bill inflated. For model calls, OWASP lists this as LLM10, Unbounded Consumption.

  8. Prompt injection and over-permissioned agent tools

    An agent with an admin key, access to every table and the ability to send email will use all of it when the instruction arrives inside a document somebody planted. Prompt Injection is LLM01 and Excessive Agency is LLM06 in the OWASP Top 10 for LLM Applications 2025.

03By tool

Where we look first, depending on what built your app

This is a starting map, not a verdict on any product. The platforms patch their own bugs. The rules, keys and routes inside your project are yours.

Lovable, Bolt and v0

Generated front end, usually on a Supabase backend

  • RLS on every table, and whether each policy compares the row owner to the caller
  • A secret key anywhere in client code or in a public repository
  • Public storage buckets holding private files
  • Edge functions that take a user ID from the request body instead of the session

Public record: CVE-2025-48757, published May 30, 2025, describes insufficient Row Level Security policies in Lovable-generated projects and is rated 9.3 (critical). The record is tagged as disputed by the vendor.

Base44

Hosted app, database and authentication on one platform

  • The access rules on each data entity: who can read, create, update and delete
  • What every role can do, tested with a real account for each role
  • Backend functions and integrations that hold secrets
  • Whether a private app is truly limited to the people you invited

Public record: in July 2025 Wiz Research reported a platform flaw that allowed unauthorized access to private Base44 apps. It was fixed in less than 24 hours, with no evidence of exploitation. A platform fix protects the platform. It does not review the rules inside your app.

Replit

Full-stack app with its own server code and database

  • Secrets written into source files instead of the secrets manager
  • Routes that check for a login but not for ownership of the record
  • Development settings and databases that carried over to production
  • Debug and admin routes left reachable from the internet

Cursor and Claude Code

Your own repository and your own infrastructure

  • Authorization on every route, because no platform is doing it for you
  • Input validation on the server, CORS, security headers and rate limits
  • The dependencies the model picked, and the versions it pinned
  • What the coding agent itself can reach: tokens, production data, deploy rights

Built on Firebase instead? The first stop is the security rules, and whether they are still in the open mode used during development. Not sure what your app runs on? Choose "Not sure" in the form and we will work it out on the call.

04Scope

What the audit covers

Nine areas, one report. The scope for your app is fixed in the proposal before work starts.

  • Code

    We read what the AI wrote: routes, server functions, data access, and the parts that handle money and identity. We look for checks that exist only in the interface.

  • Configuration

    CORS, security headers, cookie flags, environment separation, who can deploy, and whether preview or debug modes are reachable in production.

  • Authentication and sessions

    Sign-up, login, password reset, magic links and OAuth. What logout really ends, whether reset links work once, and whether admins have a second factor.

  • Data access

    The center of the audit. For every table and every route that takes an ID: who can read it, who can change it, and what stops customer A from seeing customer B.

  • Secrets

    Keys in the client bundle, the repository, git history and logs. A leaked key has to be rotated, not just deleted. The old value works until you revoke it.

  • Dependencies

    The packages the model chose: versions with known vulnerabilities, abandoned libraries, a missing lockfile, and anything installed that nothing uses.

  • LLM features

    Injection through user input, documents and web pages, what the agent's tools may do, whether one customer's data can surface in another's answer, and whether usage has a ceiling.

  • Light load test

    A short, controlled test on the paths real users take. At what traffic does response time climb, and which component gives out first? It is not a denial-of-service test.

  • Architecture and cost under load

    Single points of failure, work that belongs in a queue, missing indexes, backups nobody has restored, and what the bill does when traffic or model usage grows tenfold.

Findings are tagged with their category in the OWASP Top 10:2025, and LLM findings with the OWASP Top 10 for LLM Applications 2025, so a customer's reviewer can map them to a framework they know. For a longer checklist, see the OWASP Application Security Verification Standard.

05Scan vs audit vs pentest

A scan, an audit and a pentest answer three different questions

A scan asks: does this match a known problem? An audit asks: is this built correctly? A pentest asks: what can an attacker actually do? Most apps built fast need the middle one first.

Automated scan, audit and penetration test: what each one coversA grid with three columns: automated scan, this audit, and penetration test. Known vulnerable dependencies: scan yes, audit yes, pentest partly. Secrets and misconfiguration: scan partly, audit yes, pentest partly. Who can read whose data: scan no, audit yes, pentest yes. Business logic abuse: scan no, audit partly, pentest yes. Chained attacks on the live system: scan no, audit partly, pentest yes. Fixes written for your code: scan no, audit yes, pentest partly.ScanautomatedAuditthis servicePentestadversarialKnown vulnerable dependenciesYesYesPartlySecrets and misconfigurationPartlyYesPartlyWho can read whose data (IDOR, RLS logic)NoYesYesBusiness logic abuseNoPartlyYesChained attacks on the live systemNoPartlyYesFixes written for your codeNoYesPartly
Typical coverage. A real engagement depends on its scope, and a penetration test given the code covers more than one that starts blind.

Automated scan Minutes, by a tool

A tool compares your app with a list of known problems. The scan built into your app builder belongs here.

Finds
Vulnerable packages, some exposed keys, missing headers, tables with RLS off.
Misses
Whether a rule is correct. It sees that a policy exists, not that user B should never see invoice A.

Audit This service

People read the code, the rules and the configuration from the inside, then confirm what they suspect with test accounts.

Finds
Broken authorization, weak rules, leaked secrets and unsafe LLM tools, each with a fix for your code.
Misses
Long exploit chains and social engineering. It is not a full adversarial exercise.

Penetration test Adversarial, on the live system

Testers attack the running system the way a real attacker would, inside agreed rules of engagement.

Finds
What is exploitable in practice, including small weaknesses chained into a serious one.
Misses
Time. From the outside it rediscovers what an audit reads directly, so it works best after audit findings are closed.

If a customer or a regulator requires a penetration test, that is a separate engagement, and we scope it on request.

06Access and confidentiality

How we touch your code

Handing your repository to strangers is a risk of its own. These are the rules we work by, and they go into the written proposal.

  • Read-only access

    A read-only invitation to the repository, or an exported copy. We do not push code, change settings or deploy.

  • NDA before code

    If you want a non-disclosure agreement, we sign it before you share anything.

  • Written authorization

    No active testing starts without written approval from the system's owner. It names what is in scope, what is off limits, when we test and who can stop the test.

  • Test accounts, not real users

    We test with accounts created for the audit, one per role. We never ask for a real user's password, or for keys sent by form or email.

  • Least data

    We look at how data is protected, not at the data. If personal information turns out to be reachable, we report that and do not copy it.

  • Deleted afterwards

    When the engagement ends we delete our copies of your code, the exports and the test data. A critical finding does not wait for the report: we tell you as soon as we confirm it.

07The deliverable

What you get: a report you can act on, not a PDF of warnings

The report is written for two readers. The summary is for the person who decides. The findings are for the person, or the AI tool, that fixes.

  • Executive summary

    One or two pages in plain language: where you stand, what is urgent, what it takes. For a co-founder, an investor or a customer's reviewer.

  • Findings ranked by severity

    Each finding is rated Critical, High, Medium or Low, with the reasoning for your app, and tagged with its OWASP category.

  • Reproduction steps

    The exact request, the account used and the result, so you can watch the problem happen instead of taking our word for it.

  • Fix guidance

    What to change and where: a file, a policy or a setting. Never a line like "improve security posture".

  • Prompts or diffs for your AI tool

    A prompt to paste into Lovable, Cursor or Claude Code, or a diff, written so the tool fixes that one thing and leaves the rest alone.

  • Retest

    After you fix, we return to every finding, confirm the fix holds and nothing new opened, and update the report.

What one finding looks like

Illustrative example. Not from a client engagement.

AUTH-02HighA01:2025 Broken Access Control

Any signed-in user can read another customer's invoices

Where
GET /api/invoices/[id] and the RLS policy on table invoices
Steps to reproduce
  1. Sign in as test user A, open an invoice and copy its URL.
  2. In a second browser, sign in as test user B.
  3. Paste user A's invoice URL.
  4. The server answers 200 with user A's invoice. Expected: 404.
Impact
Sign-up is open, so anyone with an email address can read every customer's billing details by counting through invoice IDs.
Fix (diff)
-create policy "read invoices" on invoices
-  for select using (true);
+create policy "read own invoices" on invoices
+  for select using ((select auth.uid()) = user_id);
Prompt for your AI tool

In the invoices API route and the RLS policy on the invoices table, restrict reads to the row owner. Take the user ID from the authenticated session, never from the request. Return 404 when the invoice belongs to someone else. Add a test where user B requests user A's invoice and gets 404. Do not change any other policy or route.

Status after retest
Closed. User B now receives 404 on user A's invoice, in the API and directly against the database.

How severity is decided

Severity matrix: impact against how easy the issue is to reachA three by three grid. Columns show who can reach the issue: someone with insider access, anyone with a signed-in account, or anyone on the internet. Rows show impact. Many users affected: high, high, critical. One account or feature: medium, high, high. Minor information: low, low, medium. A ring marks the illustrative finding AUTH-02 in the cell for many users affected and reachable with a signed-in account, rated high.Needs insideraccessNeeds asigned-in accountAnyone onthe internetImpact: many users, their data or their moneyHighHighCriticalImpact: one account or one featureMediumHighHighImpact: minor information, no user dataLowLowMediumAUTH-02
Illustrative. The ring marks the sample finding AUTH-02: it affects many users and needs only a signed-in account.

Two questions set the rating: how much damage, and how easy it is to reach. A flaw that exposes every customer and needs nothing but a free account outranks one that needs an insider.

The four labels follow the qualitative scale of CVSS v4.0, published by FIRST:

  • Critical9.0 to 10.0
  • High7.0 to 8.9
  • Medium4.0 to 6.9
  • Low0.1 to 3.9

08Process

Six steps. Nothing starts until you approve the scope.

You know what will be examined, what it costs and who does what before anyone opens your repository.

The audit process in six stepsA vertical timeline of six steps. One: a scoping call, together. Two: a written proposal with scope, limits and price, from us. Three: authorization and read-only access, from you. Four: review and testing, by us. Five: the report and a walkthrough, together. Six: you fix and we retest each finding.1Scoping callthe app, the data, the deadlineTogether2Written proposalscope, limits and priceUs3Authorization and accesssigned approval, read-only repoYou4Review and testingcode, config, rules, light loadUs5Report and walkthroughfindings, repro steps, fixesTogether6Fix and retestyou fix, we verify each findingTogether
Who acts at each step. Step four is the only one where you can stop thinking about it.
  1. Scoping call

    A short call, no charge. What the app does, what data it holds, which tool built it, and the date you are working toward.

  2. Written proposal

    The scope, what is out of scope, the schedule and the price, in writing. Nothing starts before you approve it.

  3. Authorization and access

    You sign the authorization, invite us with read-only rights and create a test account for each role.

  4. Review and testing

    We read the code and configuration, test the data rules, exercise the LLM features and run the light load test in the agreed environment.

  5. Report and walkthrough

    You receive the report and we go through it with you on a call until the fix for each finding is clear.

  6. Fix and retest

    You or your AI tool apply the fixes. We answer questions along the way, then retest every finding.

What an audit is not

  • An audit is a snapshot of a defined scope at a point in time. Code written afterwards has not been reviewed.
  • It shows what we found in what we examined. It does not prove that nothing else exists.
  • We do not promise an app that cannot be breached. Anyone who promises that has not tested enough.
  • We do not issue certificates or attestations, and this is not a SOC 2 or ISO 27001 report.

09Self-check

Score your app in five minutes: 15 questions

Answer honestly. Not sure counts as open, because an unknown is exactly what an attacker tests first. Your answers stay in this browser tab.

Data access

  1. Is Row Level Security, or your backend's equivalent, enabled on every table that holds user data?

  2. If user B pastes the URL of user A's record, do they get an error instead of the record?

  3. Does every server route check who is calling and whether the record is theirs, not only that someone is logged in?

  4. Are your storage buckets private, with private files served through signed URLs or access rules?

Secrets

  1. Have you searched the JavaScript you ship for secret keys (database, payments, LLM) and found none?

  2. Do secrets live in your platform's secrets manager, not in source files or git history?

  3. If a key leaked tomorrow, do you know how to rotate it and what would break?

Abuse and cost

  1. Is there a rate limit on login, sign-up, password reset and anything that sends email or SMS?

  2. Do your AI endpoints have a per-user limit, and is there a spending cap or alert on the model account?

  3. Do your webhooks verify the sender's signature before they act?

  4. Is CORS restricted to your own domains?

AI features

  1. If your app has an AI agent, are its tools limited to what the task needs, with a person approving anything destructive or outbound? (No AI features: answer Yes.)

Operations

  1. Has a backup been restored at least once, as a test?

  2. If the app went down or errors spiked at night, would an alert reach a person?

  3. Has a person, not only an AI tool, read the authentication and payment code?

The two-browser test: two accounts, two windows, one question

Questions 2 and 3 are the ones people answer wrong most confidently. This is how to check them on your own app:

  1. Create two accounts in your own app, A and B, in two different browsers.
  2. As A, create a record: an order, a project, a file. Copy its URL and note any ID in it.
  3. As B, paste that URL. Then try the ID in other places you can find: an edit page, an export link, a file download.
  4. Open dev tools as B, find a request that returns your own data, and replay it with A's ID.
  5. If any of these shows A's data to B, you have a broken access control finding. Stop, and do not test anyone's app but your own.

10After launch

An audit is a snapshot. After launch you need to see what is happening.

The audit finds what is open today. Monitoring shows what goes wrong next month: a webhook that stopped arriving, a destination that went down, a model bill that doubled.

One tool for that is HookGet, an event and webhook platform. Disclosure: HookGet is Shai Truchman's own product. The facts below were read on hookget.com. The audit does not depend on it. Any monitoring you already trust does the job, and none of it replaces an audit.

  • Eight delivery attempts by default, over about 21 hours, or your own retry schedule per destination
  • A timeline for every attempt: status, response time and the first kilobyte of the response
  • A failed-delivery queue you can inspect and replay with the original event ID
  • A destination is paused after 50 consecutive failures, or immediately on a 410, and the pause is itself an event you can listen to
  • Token and dollar cost per AI model, read from the providers' APIs

11Who does the work

Shai Truchman and a team of experts

The audit is led by Shai Truchman, with a team of experts. Shai's background:

  • Solution Architect at Salesforce
  • Chief Digital Officer at Fattal Hotels and at the Daka 90 group
  • CEO of JDate Israel at Spark Networks

Shai also builds and runs his own software products. People who operate production systems know where they break, which is why the report comes with a fix that fits your code, and someone to ask. There are no certifications, client logos or invented numbers on this page. If your customer needs a test from an accredited firm, we will say so on the first call.

12FAQ

Questions founders ask before an audit

Is my Lovable, Base44 or Bolt app secure?

Nobody can tell from the outside, and that includes you. These platforms provide hosting, authentication and a database that can be configured safely. Whether your app is safe depends on what was generated inside it: the data rules, the routes, where the keys ended up. An app can pass every demo and still let one signed-in user read another user's records.

How do I check if my AI-built app is exposing user data?

Run the two-browser test. Create two accounts in your own app, create a record as the first user, then try to open it as the second by pasting its URL or changing an ID. Then search the JavaScript your site ships for secret keys, and confirm that Row Level Security, or your backend's equivalent, is enabled on every table with user data.

What does a vibe code security audit cost?

There is no price list on this page. The cost depends on scope: how many screens, routes and roles the app has, whether it has LLM features, and whether a load test is included. After a short scoping call you get a written proposal with the scope, the schedule and the price, before any work starts.

What is the difference between a security scan, a code audit and a penetration test?

A scan is a tool comparing your app with a list of known problems. It is fast, and it misses anything that depends on your business rules. A code audit is people reading your code, rules and configuration from the inside and confirming findings with test accounts. A penetration test is people attacking the running system the way a real attacker would. For an app built fast with AI tools, the audit usually comes first.

Is the built-in security scan in Lovable or Base44 enough?

It is a good first pass, and you should run it. A built-in scan can tell you that a table has no access policy or that a key looks exposed. It cannot tell you whether a policy is correct for your product, because it does not know that a receptionist should see appointments but not medical notes. Authorization logic, webhooks, LLM tool permissions and load behavior sit outside it.

What is Supabase RLS and why does it matter?

RLS stands for Row Level Security: rules inside the Postgres database that decide which rows each user may read or change. On Supabase the browser talks to the database directly with a publishable key, so those rules are the only thing between a visitor and your tables. A table in an exposed schema with RLS disabled, or with a policy that allows everything, is readable by anyone holding the key that ships in your JavaScript.

What access do you need to my code and data?

Read-only access to the repository or an exported copy of the project, a test account for each role, and written authorization from the system's owner before any active testing. We do not need write access, production passwords or real user accounts. If you want an NDA, we sign it first. When the engagement ends, we delete our copies of your code and the test data.

How long does a production readiness review take?

It depends on the size of the app and on what is in scope, so this page does not promise a number of days. A small app with one role is a much shorter job than a multi-tenant product with agents and payments. The written proposal states the schedule, and nothing starts until you approve it.

Can you load test an app built on Supabase or another hosted backend?

Yes, as a light and controlled test. We agree in advance on the environment, the hours and the traffic level, and we stay within the hosting provider's terms. The aim is to learn where response time starts to climb and which component gives out first, such as a connection pool or an unindexed query. It is not a denial-of-service test, and it runs only with your written authorization.

Do I need a pentest before my first enterprise customer?

Read the customer's questionnaire first. Many ask when the product was last tested, how customer data is separated and how keys and backups are handled. An audit report with an executive summary gives you grounded answers. Some customers specifically require a penetration test, sometimes from an accredited firm, or a SOC 2 report. An audit does not replace those, but closing its findings first makes them easier to pass.

Will you fix the issues you find?

The audit is built so that you can fix them yourself. Each finding comes with fix guidance and a prompt or a diff that your AI tool can apply, scoped to change one thing. You or your developer apply the fixes, we answer questions about the right way to close each one, and then we retest every finding.

Who performs the audit?

Shai Truchman and a team of experts. Shai was a Solution Architect at Salesforce, Chief Digital Officer at Fattal Hotels and at the Daka 90 group, and CEO of JDate Israel at Spark Networks, and he builds and runs his own software products. Testing happens only with the written authorization of the system's owner.

13Start here

Get a written audit proposal

Tell us what you built and what it holds. A person on the team reads every request and replies with questions or a time for a short scoping call. After the call you get a proposal with a fixed scope and a price.

  • The scoping call is free, and an NDA is available on request
  • No testing starts without your written authorization
  • Do not send code, passwords or keys through this form

Prefer to reach Shai directly? truchman.com

For example: what the app does, what data it holds, and any date you are working toward. Please do not paste passwords, keys or code.

Sources

Every source was read on . Quoted sentences are verbatim.

Lovable, Base44, Bolt, Replit, v0, Cursor, Claude Code, Supabase, Firebase and Stripe are trademarks of their owners. We are not affiliated with or endorsed by any of them.