← All field notes

AI app security review: the flaws we find most often

What an AI app security review should test: customer isolation, payments, files and secrets. See real finding patterns, a sample report and audit pricing.

Jun 30, 2026 · 12 min read · Updated Nov 14, 2026


Field Notes from Thunkle, a studio that takes AI-built apps from prototype to secure, production-ready software.

An AI app security review checks whether the code enforces your product's rules, not just whether the screens work. That means testing which records each customer can reach, which values they can change, and who can trigger payments, file downloads or privileged backend operations.

That is the work I do at Thunkle: reviewing applications built with tools such as Lovable, Base44 and Replit, connecting a finding to the code behind it, and checking whether a repair holds. The patterns below come from that work. They are not a measured vulnerability rate for every AI-built app.

If you are comparing paid reviews, start with the sample security audit report. It shows the scope, evidence and re-test criteria using a fictional application. The audit cost guide explains what affects a fixed quote and why implementing fixes is a separate scope.

What should an AI app security review cover?

Agree these checks for the workflows your app actually has:

  • Customer isolation: an ordinary customer can use their own records but cannot read, change or export an unrelated customer's private data.
  • Roles and sensitive fields: customers cannot grant themselves staff access, set their own price or mark an order paid, including when the record is first created.
  • Payments and backend operations: server-side checks establish who may trigger an action. Payment events are verified and duplicate delivery does not grant the benefit twice.
  • Files and derived data: downloads, previews, signed links and generated summaries respect the same intended access rules as the original document.
  • Secrets and effective permissions: privileged credentials stay server-side, while public client keys are assessed by what the deployed rules allow them to do.
  • Fix verification: repeat the original failing request on the repaired version and show that the legitimate workflow still works.

Use synthetic records and accounts in an environment you own or are authorised to test. Do not probe another customer's data to see whether a check works. A review should state the environment, source revision, tested paths and exclusions; it should not imply everything was covered.

For example, a fictional booking app might let a customer edit their delivery note and their payment status through the same update. Owning the booking makes the first action reasonable, not the second. A developer needs to separate those permissions and test the request directly, even if the interface hides the payment field.

An app can work normally while those rules are wrong. An owner who tests only their own account has little reason to notice.

That is what makes these flaws dangerous. The part of an app you can see, the interface, the sign-up, the checkout, is the part these tools build well. The part you cannot see, the rules for who is allowed to read and write each piece of data, is where they fall short. A missing rule does not cause an error. It produces an app that works and is exposed at the same time.

What follows is the set of issues I find most often, with examples of what they exposed. Every example is real and anonymized to its sector.

For the aggregate counts behind these patterns, see our AI-built app security data from 1,236 scans. The page separates our live operational totals from the frozen Vibe App Scanner research cohort and explains the limits of each.

Unprotected databases

Most of these apps store their data in a backend service like Supabase or Firebase. Their security depends on the effective permissions and configuration of the deployed project. Supabase combines database grants with row-level security; Firebase uses security rules and other access controls. A public API key is not itself a secret, but overly permissive access rules can expose private records through public APIs. This is the broadest form of broken access control, and it is the category I see most.

What this exposes, in practice:

A lending product had a table of full bank account numbers readable by anyone holding the public key. A health app exposed patient access codes and payment codes the same way. An education platform exposed the stored Google authentication tokens of its users, which is enough to access their accounts elsewhere. In each case the data was private in intent and public in fact.

Reading is the milder version. In several apps the tables could also be written to by unauthenticated strangers. I have seen this on tables named orders, payments, and transactions, where an outsider could insert a forged record the app would treat as real. In one app a table named security_events, the audit log meant to record suspicious activity, was itself writable by anyone, so an attacker could write over the record of their own actions.

The same misconfiguration extends to database functions. I have found privileged functions left callable with the public key, including ones named generate_license_key and generate_transfer_token. A stranger could call these directly and have the database mint a valid license or transfer token for them.

Firebase fails in a blunter way. Several apps were running in test mode, the temporary wide-open setting Firebase ships for local development, except they were live in production. One app's real-time database was readable from the root down, exposing top-level sections named users and wallets. Anyone who found the address could read it. Another left its storage open to anonymous uploads, so a stranger could put files of their choosing into the app's own storage, which invites everything from hosting malware to running up storage costs.

None of this is necessarily visible in an ordinary user journey. The application behaves normally. The exposure is only apparent to someone using the public key the way an attacker would.

Reading another user's data (IDOR)

I find this one less often than the open databases above, but its impact is among the most serious, which is why it deserves close attention. The formal name is insecure direct object reference, or IDOR. It is a specific failure of object-level access control.

The app checks that you are signed in. It does not check that the record you asked for belongs to you. Records are usually addressed by an identifier in the request, often a sequential number. You sign in as yourself, load your own record at an address ending in /1024, change it to /1025, and the app returns the next user's record. Because the IDs increment, you do not have to guess. You count. Everything the app addresses this way is reachable: profiles, orders, accounts, documents.

I have found this in applications where the data is highly sensitive. A platform holding bond investments, where one account could read another's holdings by incrementing the ID. A trading application. A law firm's client portal. In each case the underlying fix was minor and the exposure was complete.

What makes this difficult is that it is invisible to the person who built the app. When they sign in and view their own data, everything is correct. The flaw exists in the relationship between two accounts, and it is only found by holding two accounts and comparing them. An owner testing their own app will not see it, and neither will most automated checks. This is why an application that looks entirely normal can still expose every customer's data to every other customer.

For a reproducible example, read what a one-account security test misses, then try the free two-account Supabase checker in a disposable environment you control.

Identifiers leaking through public features

Not every exposure comes from a missing lock. Some come from a feature that is meant to be public but gives away more than it should.

A leaderboard, a public profile page, a list of recent activity, a reviews feed: these are built to be seen, so no one thinks of them as a security surface. But they are often assembled by returning a database record straight to the page, and that record carries fields the page never displays. I regularly find internal user IDs, email addresses, and other personal data sitting in the data behind a public feature, unused by the visible page but readable by anyone who looks at the response.

On its own that is a privacy problem. The larger issue is what those identifiers unlock. A public leaderboard that exposes each user's internal ID hands an attacker the exact set of IDs needed for the flaw above. The leaderboard tells you which numbers are real, and the missing object-level check lets you use them to pull each user's private record. Two issues that look minor in isolation combine into full account enumeration. Neither would stand out to the person who built the app, because both features are working as intended.

Exposed secrets

Some values are meant to stay on the server, where users cannot reach them. These include API keys, service credentials, and database connection details. To make an integration work, they are sometimes placed in the code that runs in the browser, where they can be read by anyone who opens the developer tools.

I have found a database's service key, the most privileged credential it has, exposed this way; it grants full access regardless of any other protection in place. I have found keys for paid AI services left in client-side code, in one app several of them bundled together. Those keys often have no spending limit, so a third party can use them at the owner's expense until the bill arrives.

The more serious versions remove every other obstacle at once. I have found hardcoded admin login credentials sitting in client-side code, which is a direct route to an administrator account. I have found database connection strings carrying root access, which is full control of the database with nothing else in the way. A credential that has appeared in the browser should be treated as already compromised, because every visitor can read it.

Access from any website

CORS (cross-origin resource sharing) controls when a browser lets one origin read responses from another. It is not authentication, authorization or a general block on sending requests.

Reflecting an untrusted origin can expose authenticated responses when the browser also sends the necessary credentials and the response allows credentialed access. Confirm those conditions in an authorized browser test. A permissive header alone does not establish account compromise, and public unauthenticated resources can legitimately use a wildcard.

Review cookie settings, session handling and CSRF protections separately. A developer needs to distinguish an intended public API from an endpoint serving private account data.

Authentication and configuration

Two smaller issues appear consistently. The first is weak password handling: apps that accept very short or trivial passwords, and login endpoints with no rate limiting, which lets an attacker guess passwords rapidly without being blocked. Together these make accounts straightforward to break into.

The second is security misconfiguration. Standard protective headers that a web app is expected to send to the browser, such as a content security policy, are often absent. The impact depends on the application and attack path. A missing header is a reason to review the configuration, not automatic proof of a serious vulnerability.

What the AI leaves behind

Occasionally the app reveals how it was made. In one app the AI assistant's full system prompt was sitting in the client-side code, readable by any visitor, beginning "You are [Assistant], a direct, raw assistant. No lectures, no warnings, no disclaimers." Others left behind the model's working files, exposed notes on migrations and configuration, shipped to production and never removed.

I also find administrative panels and debug endpoints left reachable without authentication, which depending on what they control can be serious in their own right.

These are not always the most severe findings, but they are the most telling. They show an app assembled by a tool that was never asked to clean up after itself, and they give anyone looking a head start on everything above.

What you can check yourself

If you have built an app this way and it has real users, several of these are worth checking directly.

Review effective grants, row policies and function permissions against the intended public and private data. Keep privileged credentials server-side and replace and revoke any exposed secrets; public project keys are different. In a staging or disposable environment you control, use two authorized test accounts and synthetic records to check cross-account access without touching another customer's data. Look at the raw data behind any public feature, such as a leaderboard or profile page, and check it is not returning IDs or personal fields the page never shows. Review your password requirements, add rate limiting to your authentication endpoints, and check which sites your app accepts requests from.

These checks can catch important problems. They do not establish that every product rule is correct or that a later change has not reintroduced a flaw. Finding a vulnerability, repairing it and verifying the deployed repair are separate tasks.

When to bring in a developer

Get an independent review before relying on an app for private customer records, different account roles or real payments, especially if you cannot explain where those permissions are enforced. A scanner report is a useful starting point, not a replacement for agreeing the expected behaviour and testing it.

Thunkle's paid security audit combines source review with agreed tests of the running app. Audits start from $750 USD for a small app or selected critical workflows, with a fixed quote confirmed before work begins. Larger apps and wider reviews cost more. You receive prioritised findings, evidence, remediation guidance and a free re-review of agreed fixes. Implementation is quoted separately, and no audit guarantees that every vulnerability has been found.

To see the difference between a worked example and client work, compare the fictional sample report with the anonymised audit findings. If you want a quote, send your app URL and the workflows you need reviewed. Do not send passwords, production secrets or customer records.

For a structured self-serve starting point, the Vibe Coding Security Launch Kit collects the checks, coding prompts and fix patterns into a practical guide. It does not include a review of your app or replace a professional audit.

That is the work we do at Thunkle. We review an app for these issues and re-test agreed fixes. Implementation and ongoing review are separately scoped. If you would like a security review of your app, you can request a security audit quote or reach us at thunkle.ai.

Find out what your app actually allows.

Get a developer-led review of the customer data, permissions and payment paths you rely on. Receive evidence-backed findings, remediation guidance and a free re-review of agreed fixes. Implementation is quoted separately.