SECURITY AUDIT · AI-BUILT APPS

Your app already has users, data or payments. I show you what's exposed and how to fix it.

I review the security of AI-built apps (Lovable, Cursor, Bolt, v0) by hand, using the OWASP methodology. It's for anyone who already has users, data or payments at stake. You get a report with every finding, its severity and its concrete fix, written so you understand it even if you don't code. It starts with a 30-minute call.

I'll also tell you what's already fine.

Versión en español

A phone with a warning sign under a magnifying glass, next to a padlock and a shield with a check mark.

What exactly do I review?

Seven layers, from the browser to payments. In each one I check what I would check if the app were mine.

The express review covers the application layer against the OWASP checklist. The full audit also goes deep into the database, secrets, authentication and headers.

01

Frontend

Everything that reaches the browser can be read by anyone. I check which data, keys and routes travel there without needing to.

02

API and backend

The doors your app uses to fetch and save data. I check that each one asks who you are, validates what it receives and doesn't answer with more than it should.

03

Database and RLS

In Supabase, RLS policies decide which rows each user can see. Get them wrong and one user reads another's data. I review them one by one, along with the schema.

04

Authentication and permissions

Who can get in and what they can do inside. I look at sign-in, sessions and whether a regular user can reach the admin panel.

05

Secrets and environment variables

API keys, passwords and tokens. I look for the ones left in the repository, in the browser code or in variables that shouldn't be public.

06

Deployment and headers

How the app is published: security headers, CORS, the configuration it shipped with and what your error messages give away.

07

Payments and integrations

Payment provider, email, AI, CRM: everything you connect. I check what data goes out, with which permissions, and what happens if one of those pieces receives something unexpected.

How an audit works

Five steps, plus one more if you want me to apply the fixes.

  1. You tell me what you've built

    A 30-minute call. What the app does, what you built it with, who uses it and what worries you. That's where I tell you whether I'm a fit.

  2. You give me read-only access

    Read access to the repository, or a ZIP of the code, and the app's URL. If there's a database, the schema and its policies. Auditing needs no write permissions.

  3. I review by hand against the OWASP checklist

    I read the code and the configuration layer by layer, with the OWASP checklist as the guide. By hand, because a tool doesn't know what your business does with that data.

  4. You get the report

    Every finding with what's happening, the real risk, where it lives and how to fix it. Ranked by severity, so you know where to start.

  5. We clear up questions

    We go through the report together, you ask whatever you need and we decide what to fix first.

  6. I apply the fixes and re-test

    If you prefer, I make the fixes myself in your repository, as Pull Requests you approve. Then I re-test every point and stay available for 30 days.

Three scopes, depending on where your app is

Every audit includes a by-hand review of the application layer against the OWASP checklist. And a report with every finding, ranked by severity and with its concrete fix. Depending on the scope, it adds a deep review of RLS, secrets, authentication and headers, or the fixes as Pull Requests, re-tested. On the call I tell you which one fits.

01

Express review

1-2 business days
Who it's for
An MVP you're about to show or launch, when you want to do it without surprises.
What it solves
Knowing whether anything serious is in there before you open it to more people.
What you get
The application layer reviewed against the full OWASP checklist and a report with the findings ranked by severity, each with its concrete fix.
Out of scope
The deep review of RLS, secrets, authentication and headers belongs to the full audit. Applied fixes, to the audit with fixes. Not a penetration test.
02

Full audit

4-5 business days
Who it's for
Production apps with users, data or payments.
What it solves
Knowing what's really exposed, in which order to fix it, and understanding it without being technical.
What you get
Everything in Express, plus a deep review of RLS and Supabase, secrets, authentication and headers. And a 30-minute call to go through it together.
Out of scope
Applying the fixes. I leave them explained for your team, or I do them myself in the next scope. Not a penetration test.
03

Audit with fixes

8-10 business days
Who it's for
Anyone who wants the problem solved, not just diagnosed.
What it solves
Not having to find someone else who understands the report and carries it out.
What you get
Everything in Full. The fixes applied by me as Pull Requests in your repository, a re-test of every point and 30 days of support.
Out of scope
The re-test confirms each fix works; it isn't a certification or a penetration test. It covers the report's findings; anything new that comes up, we talk about it.

Turnaround is approximate, in business days, and the exact figure goes in writing in the proposal.

How much does a vibe coding security audit cost?

It depends on the scope: the size of the app, what sits behind it (database, payments, integrations) and whether you want me to apply the fixes. There's no price table because no two apps are alike. After the call I send you a written proposal with scope, turnaround and price, before anything starts.

No commitment until that proposal.

Proposal amounts exclude VAT. In Spain, VAT is added. EU businesses with a VAT number get a reverse-charge invoice. Outside the EU, no VAT applies.

Did you ask the AI to review its own code?

Building an app by describing it to an AI, what people call vibe coding, is fast and normal. When you're done you ask it to check its work, and it tells you everything looks fine.

It's not that it's lying to you. But it reviews with the same criteria it built with, so it tends to miss the gaps it left.

An independent human review looks from the outside, with a checklist that doesn't depend on how the code was written.

Asking the AI to check itself vs an independent human review
AspectAsking the AI to check itselfIndependent human review
CoverageTends to repeat the blind spots it built withFull OWASP checklist, layer by layer
Outcome"Looks fine to me"A written report with findings ranked by severity
FixesScattered patches, no sense of priorityThe concrete fix for every finding, and where to start
AccountabilityNobody owns the outcomeA name and a reputation behind it

Keep building with AI; it's good at that. For the review, better someone who didn't write that code.

I audit apps built with Lovable, Cursor, Bolt or v0

The tool isn't the problem. Speed is: a whole app ships in a weekend, and it's easy not to stop and look at the configuration.

I build with these same tools every day, so I know where the gaps usually end up.

Lovable

Usually with Supabase behind it: it stores your data and serves it straight to the browser. That's where RLS policies rule, the rules that say which rows each user can see.

I check those policies and the two keys. The anon key is public and obeys the rules; the service_role key bypasses them all and must never leave the server. And public storage: the files anyone can open with the link.

Cursor and Claude Code

Custom code that grows very fast. I check authentication, meaning who gets in and how, and input validation: what the app accepts without checking. And the secrets forgotten in the repository: keys pushed once and still there for anyone who knows where to look.

Bolt

MVPs deployed in hours. I check environment variables, where the app's keys live, and API routes, the addresses it asks for data from. And what got exposed to the browser by accident.

v0

Interfaces wired to real APIs. I check what travels to the browser and what should have stayed on the server: a key in the frontend can be read by anyone in two clicks.

In all of them I also check CORS and headers, which often stay as they came out of the box. CORS decides which websites may call your API; headers, what you let the browser do with your page.

What the terms mean

Five terms you'll read in the report, explained briefly.

RLS
RLS (row-level security) is the set of database rules that decides which rows each user can read or change. If a table doesn't have them switched on, anyone with the public key can read all of it.
anon and service_role keys
Supabase gives you two keys. The anon key is public, lives in the browser and obeys RLS. The service_role key bypasses every rule, so it belongs on the server only. If it reaches the browser, the database is wide open.
OWASP and its checklist
OWASP is a non-profit foundation that publishes open web security guides. Its checklist is a list of checks that doesn't depend on who wrote the code. That's why I review every app with the same criteria.
Security headers
Instructions your server sends the browser with every page: whether it can be embedded in another site, where scripts may load from, whether it must always use HTTPS. Set properly, they leave common attacks less room.
Application layer
Your app as it's programmed and configured: screens, API routes, forms, sign-in and the services it connects to. It's what I audit: the code and its configuration, from the inside, without attacking the app from outside.

What I don't do

So there are no misunderstandings, this stays out.

Penetration testing

I don't attack your app from the outside: I review the code and the configuration from the inside. If your case needs a pentest, I tell you.

Certifying GDPR or SOC 2

I show you what's exposed and how to close it. Certification is a different job, done by a different kind of company, with a different piece of paper.

Promising absolute security

An audit reduces risk and puts it in order. No report can assure you that no flaw exists, and your app keeps changing afterwards.

Reviewing what's outside the scope

I audit what we agreed in the proposal. If I see something outside it along the way, I tell you and we decide whether to add it.

EU-based, with GDPR in mind

I work from Barcelona and invoice from Spain. When I review your app, I also look at what could get you in trouble under GDPR.

For example: personal data visible to people who shouldn't see it. Forms sending information to services you hadn't planned on. Permissions that show more than they should.

I don't certify compliance. I show you what's exposed and how to close it; what you do with that is your call, with your legal advisor if you have one.

What happens to your code

It never leaves my machine. I don't share it with anyone and I delete it when the project closes. If you want an NDA, we sign it before you show me anything.

Invoicing

If your business is in the EU and has a VAT number, the invoice is reverse-charged. The figures go in the proposal.

An audit with fixes included

With the express review and the full audit you get the report: every finding with its severity, its real impact and the concrete fix. What to change, where and why. Your team applies it, or whoever you choose.

With the audit with fixes, I apply them. I work on your repository and send you every change as a Pull Request.

A Pull Request is a proposed change to the code. You see which lines change and why, and nothing lands in your app until you or your team approve it.

Then I re-test every point to confirm the fix works. That re-test verifies what we fixed; it isn't a certification and it doesn't cover what wasn't in the report.

And for 30 days, if anything related to the fixes acts up, you write to me and we look at it.

SOCIAL NETWORK · STARTUP ECOSYSTEM

A public case: Balority

Working session with the Balority team
Working session with the Balority team.

Balority is a startup-ecosystem social network: it connects founders, investors, mentors and talent. I reviewed its application-layer security using the OWASP methodology.

I found 29 issues: 5 high, 10 medium and 14 low. I delivered the diagnosis with every point, its severity and its fix, ordered so they knew where to start.

What I can tell you is what I found and what I delivered.

Visit Balority

One finding, from the inside

Example of a typical finding (not from Balority).

Finding
The Supabase service_role key sits in the code the browser downloads. Anyone who opens the developer tools can read it and, with it, read and modify the whole database, bypassing the RLS policies.
Severity
High.
Fix
Take that key out of the frontend and use it only on the server. Generate a new key, because the old one already counts as exposed. And review the RLS policies so the public key can only do what it should.
What changes for the client
A regular user can no longer see or touch other people's data.

Who does the work

I'm Daniel Brosed, a full-stack and AI developer. I work from Barcelona.

I build apps with the same tools I review. I hold ten Anthropic Academy certifications and have completed nine Cyfrin Updraft courses, smart contract security among them.

Vibe coding security audit FAQ

Does this work if my app wasn't built with AI?

Yes. The methodology is the same: the OWASP checklist applied to the application layer, by hand. AI-built apps are most of what I review, because they tend to ship with less prior review. But the process works for any web app.

What exactly do I get?

A written report with every finding: what's happening, how severe it is, where it lives and how to fix it, ranked by priority. In the full audit we go through it on a 30-minute call. In the audit with fixes, also the changes applied as Pull Requests and their re-test.

What do you need to start?

Read access to the repository, or a ZIP of the code, and the app's URL. If there's a database, the schema and its policies. That's enough for the express review; if I need anything else, I ask on the call.

Is this a penetration test?

No. It's an application-layer audit: I review the code and the configuration from the inside, against the OWASP checklist. I don't attack the app from the outside. If your case needs a pentest, I tell you on the call.

How long does it take?

The express review, one or two business days. The full audit, which adds RLS, secrets, authentication and headers, four or five. The audit with fixes applied as Pull Requests, re-test included, eight to ten. The exact turnaround goes in the written proposal, before we start.

How do we start?

Book a 30-minute call or message me on WhatsApp. You tell me what you built and what worries you, and I tell you whether I'm a fit. If it fits, I send you the written proposal. No commitment until then.

What happens if you find something serious?

In the report it comes with its severity, impact and fix. If you want me to apply it, we talk.

Do I need to know how to code to understand the report?

No. Every finding comes with a plain-language explanation: what's exposed, what could happen and what needs doing. The technical detail of the fix sits apart, for whoever applies it. And on the call I walk you through it calmly.

Do you review databases, admin panels or third-party integrations?

Yes, within the agreed scope. I review the database and its policies (RLS if you use Supabase), and the admin panel and who can reach it. Also the integrations you connect: payments, email, AI, CRM. On the call we set what's in.

What don't you review?

I don't do penetration testing, I don't certify GDPR or SOC 2 and I don't audit what's outside the agreed scope. If I see something beyond it while reviewing, I tell you and we decide whether to add it.

What happens to my keys, access and data?

I ask for read-only access and the minimum needed. Your code never leaves my machine, I don't share it and I delete it when the project closes. If you want an NDA, we sign it first. When we're done, you can revoke the access you gave me.

Can I share the report with my team or another developer?

Yes. The report is yours. It's written so the person who decides understands it and the person who codes can apply it, whether that's your team, another developer or me.

Does the audit guarantee my app is 100% secure?

No, and be wary of anyone who promises that. An audit reduces risk: it finds what's exposed and tells you how to close it. No report can assure you that no flaw exists, and your app keeps changing after the review.

How much does it cost?

It depends on three things: the size of the app, what sits behind it (database, payments, integrations) and whether I apply the fixes. We look at it on the call, then I send a written proposal with scope and price, before anything starts.

Want me to review your app?

No pitch, no pressure. You tell me what you built and what worries you, and I tell you whether I'm a fit.

If it fits, I send you a written proposal with scope and price. Nothing to sign until then.

Or write to me through the contact form