ekyon.Code audits for AI-built appsAsk about an audit

Lovable, Bolt, Replit, Cursor, Claude or a contractor

Code audit servicesfor AI-built and vibe-coded apps, before you scale, raise or hand over.

An independent review of the risks that matter for your next step, with evidence your engineer can check and a repair order they can start on.

What does your next step depend on?

A focused audit answers one agreed question about your app.

  • “We're about to scale. Will it hold?”

    Before you scale

    Who can reach which data, where paid features can be bypassed, and what breaks under real use.

  • “An investor or buyer will ask about the code.”

    Before you raise

    A plain owner summary of the real risks, what was checked and what wasn't, before someone else finds them.

  • “A new developer is taking over.”

    Before a handover

    How it's built, how it's deployed, and a repair order the next engineer can start on.

What a vibe-coded app usually gets wrong.

The audit starts with the risks that matter for your decision:

  • Access rules: whether one user can reach another user's records
  • Keys and secrets shipped to the browser
  • Paid features that can be used without paying
  • Database permissions left open, or checked only in the browser
  • Admin actions and AI tools that can act without a permission check
  • Setup, deployment and recovery that only the original tool understands

Sample code audit report: read the whole thing.

An example app, not a client's code. It shows exactly what you get: the owner summary, what was checked, the evidence, and repair tickets with acceptance checks.

Open the sample report
Sample report · example app · not a client's code

Workspace Notes / export review

Reporting example dated 12 November 2026. All application names, paths, revisions and observations below are invented to demonstrate the format. No repository was inspected or runtime test executed for this example.

Decision and boundaries
What must be verified before enabling document exports for customers? One repository, example revision example-revision; export lookup and its permission dependencies. Production not accessed.
Effort and method
Illustrates a scope of up to nine assessment hours including reporting, plus a one-hour walkthrough. It does not represent hours actually worked. Source tracing and configuration inspection; runtime validation unavailable.
Owner summary
Verify the export permission boundary before opening this workflow to real customer data. Sign-in is present in the example handler, but the traced path does not establish workspace membership. This is a source-supported concern, not confirmed data disclosure.
System map
Browser → export API → session lookup → export store → response. The rule to establish: the authenticated actor belongs to the workspace that owns the requested export. Upstream controls and deployed behaviour remain unknown.

Coverage register

  • Assessed in this example: sign-in and export lookup. The example handler checks sign-in before loading data.
  • Partially assessed: object authorisation. No membership decision appears in the illustrated call path; external enforcement remains unverified.
  • Not assessed: runtime responses, production configuration, related downloads, billing, uploads, recovery and load capacity.
  • Not applicable to the selected flow: AI tool execution; this example export path has no AI action.

F-01 / Export lookup does not establish workspace membership

Example location: app/api/exports/[id]/route.ts at example-revision. The pseudocode below illustrates the concern; it is not production code or an executed reproduction.

actor = requireSignedInUser(request)
export = loadExport(request.params.id)
return export // no membership decision in this traced path
Expected rule and potential impact
A member may export only documents in their workspace. If this path is reachable without another effective control, another workspace's documents could be disclosed. Actual data sensitivity and reach require verification.
Severity, exposure and confidence
Severity unassigned in this incomplete example. Confidence: source-supported concern. Runtime exposure: unknown. A missing check in the traced code does not establish that upstream or database controls are absent.
First action and owner
Assigned backend engineer: trace the deployed access path and run an authorised two-workspace dummy-data test before enabling the export feature for customers. Record revision, environment and redacted request/response evidence.
Repair direction and dependencies
If confirmed, enforce actor-to-workspace membership before returning data. Inspect shared export/download paths and intended admin exceptions. Trace the shared permission layer before estimating implementation, tests and release work; no fixed repair estimate is implied.
Acceptance checks for the repair ticket
Member A can retrieve A's dummy export. A cannot retrieve B's known dummy export by direct API request. Signed-out access is denied. Test intended admin exceptions explicitly. No unauthorised data appears in responses or logs.
Status and remaining work
Open; not retested. A reported code change is not a verified fix. Record the tested revision/environment and results before marking verified. Follow-up verification is separately scoped.

Repair order and handover

  1. Verify before deciding: backend engineer establishes the full permission path and records the dummy-data results. Missing test access stays an explicit limitation.
  2. Resolve before customer exposure if confirmed: implement membership enforcement, inspect related paths, run allowed/denied regression tests, and review the deployment. If real exposure is suspected, agree incident investigation separately.
  3. Handover: share the owner summary, coverage, evidence and repair ticket with the implementing team. Assign remaining unknowns and access-removal responsibility in the walkthrough. This sample does not certify the product or recommend a full rewrite.

In a real report, each evidence reference points to the agreed revision or a securely shared attachment. Findings separate impact, reachability, confidence, action priority and effort assumptions. Your own engineer can use the report without hiring Ekyon to implement it.

What a code audit costs

A focused code audit starts at US$1,000: up to 9 assessment hours including the report, plus a one-hour walkthrough. Fixes are quoted separately.

Focused code audit, from

US$1,000

Scope and price agreed in writing before any access.

Plan for one to two weeks after scope, access and a start date are confirmed.

Ask about an audit

Included

  • Up to 9 assessment hours: setup, investigation and the report
  • An owner summary in plain English
  • Findings with evidence, impact and confidence
  • What was checked, and what wasn't
  • A repair order with acceptance checks
  • A separate one-hour walkthrough

Not included

  • Fixing the code: quoted separately, if you want it
  • Checking the fixes afterwards
  • Penetration testing
  • Compliance certification
  • Larger reviews: quoted separately

The repair plan works without us.

Your own engineer can use the report. Hiring Ekyon to fix anything is optional, and a full rewrite is never the automatic answer.

No finding count and no safety grade.

If nothing serious turns up, the report says what was checked and what remains unknown. No audit can certify that software has no vulnerabilities.

Tell us what the app does and what you need to decide.

The stack, the flows that matter, and the decision ahead. Scope and confidentiality are agreed before anyone sees your code.

Leave blank if it isn't live yet.
Add context (optional)
Please don't send passwords, keys, repository access or customer data.

We only email you about this request. Privacy policy

The scope and price in writing, before anyone sees your code.

Before you commit

  1. 1

    Describe the app and the decision

    No code, keys or customer data

  2. 2

    Agree the scope

    Question, repositories, access and price, in writing

Then from US$1,000

  1. 3

    The audit

    One to two weeks: review, report, walkthrough

    On the scope you agreed.

How the 9 hours are usually spent
0.75 hOrient and map
Review the product decision, selected journeys, actors and system boundaries.
0.75 hSetup and baseline
Inspect run instructions, configuration and relevant tool leads. Record the review revision and missing evidence.
4 hInvestigate selected paths
Trace the agreed high-priority behaviour end to end. Runtime checks use only separately authorised environments and dummy data.
1 hValidate and prioritise
Challenge findings against available evidence, identify unknowns and separate impact from confidence. This is initial assessment, not a post-repair retest.
2.5 hWrite the report and repair plan
Prepare the owner summary, coverage register, evidence, repair tickets and acceptance checks.

Code Audit Starter Kit: check your own app first

Seven guided checks for AI-built apps, an evidence worksheet, a worked example and a brief you can hand to any engineer. Free, and readable right here.

Get one requested email with the full kit. No code or credentials needed.

Your email is used to send the kit and notify our team of the request. Privacy policy.

Read the full starter kit now — no email required

Start with one important decision

Use this kit before launch, a team handover or a repair-or-rebuild decision. It works for AI-assisted, contractor-built and in-house apps. Start with the brief, then choose the checks relevant to your product. Give the technical checks to your engineer if needed; the deeper checks can take more time.

Use only systems you own or are authorised to test. Hands-on checks belong in local or staging environments with dummy records and test accounts. Do not use customer data, live payments or destructive actions. If you cannot check safely, record Unknown. This kit is not a security certificate.

APP / DATE:
DECISION AND DEADLINE:
WHAT THE APP DOES / STACK, IF KNOWN:
USERS AND ROLES:
MOST IMPORTANT CUSTOMER JOURNEY:
WHAT MUST NEVER HAPPEN IN THAT JOURNEY:
SENSITIVE DATA, PAYMENTS, FILES OR AI ACTIONS:
KNOWN PROBLEMS:
WHO CAN EXPLAIN AND DEPLOY THE CODE:

Example rule: a member may download their workspace's documents, but never another workspace's documents. That is checkable. 'We have authentication' describes a feature, not its boundaries.

Record evidence, not ticks

  • Evidence recorded: name the path, configuration or test result, revision, date and environment. Say exactly what it establishes.
  • Concern observed: record what differs from the intended rule, without guessing the full impact.
  • Unknown: name the missing evidence and who could help. An unknown is not proof of a vulnerability.
  • Not applicable: explain why this feature or risk is absent.

Use these labels for each of the seven checks. One successful test covers that path at that revision. A hidden button, an AI assurance or a clean scanner result does not establish the whole app is safe.

1. The two-account check

Can one account reach another account's private records? Write the intended rule first. Create dummy accounts A and B in separate workspaces (or your actual ownership model). As A, create a private test item and record its known test URL or identifier.

In a separate browser profile signed in as B, request A's known dummy item directly. Ask an engineer to check the underlying API/download path too, including database and storage rules. Test signed-out access separately. Do not guess identifiers belonging to real users.

Expected evidence: A's permitted access works; B and signed-out requests return no private data. Record responses and confirm denied writes leave state unchanged. A redirect alone does not prove the API refused access. If private data is returned, involve the responsible engineer promptly to contain and investigate the exposure before expanding use.

2. Privileged credentials

Ask an engineer to distinguish public client keys from privileged credentials, then inspect browser-delivered code, repository history and relevant logs. Supabase publishable/legacy anon keys are designed for clients; secret/service-role keys are privileged. An .env filename alone does not establish that a build keeps a value private.

Optional engineer check, from a local Git repository after installing Gitleaks: the command below scans Git history and redacts detected secrets in output. It does not cover every exposure location. Keep tool version, coverage and redacted observations, never key values. If a privileged key was exposed, have its owner revoke or rotate it and assess access; deleting the latest copy is insufficient.

gitleaks git --redact

3. Paid access and repeated events

Skip with a reason if there are no paid entitlements. In the payment provider's test environment, ask your engineer to check that visiting a success URL or submitting a browser 'paid' value cannot grant access. The server must establish entitlement from trusted payment state.

Ask them to verify webhook signatures using the provider's supported method, replay the same test event and check late or out-of-order events. Expected evidence: the intended business effect occurs once, invalid events are refused and delayed events do not incorrectly change access. Keep the handler, signature-check location and observed results. A search for one SDK function is not proof of correct verification.

4. Restricted actions without the button

Choose one important action: changing roles, inviting a teammate, exporting data or deleting a dummy item. Write who may perform it. Have an engineer call its server/API path with a lower-privilege test account and while signed out, then with the intended role.

Expected evidence: the permitted action works and unauthorised requests neither disclose data nor change state. Keep the role, path, response and before/after state. Include direct database/storage access if the app exposes those paths. Hiding the menu is insufficient. If the rule fails, investigate its shared permission layer and related actions.

5. AI tools, data and spending

Skip if there is no AI feature. List the data it retrieves, tools it calls and actions they allow. Ask which permissions, usage limits and approvals the application enforces independently of model output.

In an isolated sandbox, ask the engineer to test a request for another dummy account's data or an action the test user may not authorise. Inspect configured per-user limits and failure behaviour using a small agreed test budget. Do not repeatedly hammer live login, email or paid AI endpoints. Expected evidence: the application refuses forbidden data/actions and enforces the intended usage limit. A prompt asking the model to behave is insufficient.

6. The next engineer check

Can someone other than the builder follow setup instructions and run the important flow with dummy data? Review repository scripts before running them. Ask what the relevant tests assert: permitted behaviour, denied access and an important failure or retry. Keep setup gaps, test names/results and the revision they cover.

For npm projects with a package lock, this optional command checks dependencies while omitting dev dependencies from the submitted audit. It sends dependency information to the configured registry; use it only where that is permitted. It does not change installed versions. Review advisories, installed versions and affected usage with an engineer. Development/build dependencies still need a separate review. Do not blindly apply audit fix commands or bulk upgrades.

npm audit --omit=dev

Expected evidence: another engineer can run the selected flow and explain what the tests and unresolved warnings establish. A dependency warning is a lead to investigate, not automatically an exploitable problem in your app.

7. The bad-day check

Name who receives failure alerts, controls deployment and can restore the needed data. Ask for the last relevant restore-test evidence, rollback instructions and account ownership/access arrangements. Database backups may exclude uploads and external-service state.

Expected evidence: named owners, what is backed up, a dated recovery exercise and known gaps. 'Backups enabled' is a setting, not a demonstrated restore. Plan any recovery exercise in isolation; never restore over production for this kit. Missing evidence becomes an owned investigation task.

Choose your next three actions

  • Observed private-data access, exposed privileged credentials or a similarly serious failure: involve the responsible owner promptly, agree containment and investigate. This kit cannot establish whether real data was accessed.
  • Missing evidence on an important permission, payment or data flow: make verification a task before relying on it. Do not turn every unknown into a critical finding.
  • Other improvements: prioritise demonstrated impact on the next milestone. Keep lower-value cleanup separate. Avoid calendar deadlines based only on a scanner score.
ACTION / OWNER / REVIEW DATE:
OBSERVATION OR UNKNOWN:
EVIDENCE / REVISION / ENVIRONMENT:
IMPACT ON OUR DECISION:
NEXT CHECK OR CHANGE:
ACCEPTANCE CHECKS:

Worked finding — illustrative only

Example only, not a client result: an export handler checks sign-in, then reads an export by ID. The traced source path contains no workspace-membership check. This supports a concern; runtime exposure and upstream controls have not been verified. No severity is assigned without that context.

Next action: trace the full access path and run the authorised two-workspace dummy-data test. If confirmed, enforce membership before returning data and inspect related downloads. Acceptance: permitted exports work, cross-workspace and signed-out requests disclose no private data, and the intended revision/environment is recorded. State: open, not retested. Estimate after tracing the shared access layer.

Hand this brief to any engineer

WE NEED TO DECIDE / BY WHEN:
PRODUCT / STACK:
IMPORTANT FLOW AND PERMISSION RULE:
TOP THREE CONCERNS OR UNKNOWNS:
EVIDENCE AVAILABLE (NO SECRETS):
WHAT HAS NOT BEEN CHECKED:
TECHNICAL CONTACT:
HELP NEEDED: investigate / review / repair / handover

Your existing developer may be able to resolve the questions. If you want an independent investigation, Ekyon's focused audit starts at US$1,000: up to nine assessment hours including setup, investigation and reporting, plus a separate one-hour walkthrough. Scope is agreed first. Larger reviews, repairs and follow-up verification are separately scoped.

To discuss fit, reply to this email (hello@ekyon.io) with your product, stack and decision. Leave out passwords, key values, repository access and customer data. Confidentiality and access are agreed before code is shared.

See the audit scope and illustrative report

Ekyon, Code Audit Starter Kit · 12 November 2026. Keep the evidence and use the brief with any engineer.

Reference notes (commands checked against official docs, 12 November 2026)

Questions about scope, access and expectations

What does a code audit include?

The agreed review can cover access controls, sensitive data handling, dependencies, important user flows, architecture, performance and deployment. You receive findings with evidence, business impact and a prioritised repair plan. The proposal names the repositories, review depth, access and exclusions; a focused review does not inspect every possible path.

How much does an Ekyon code audit cost?

Our focused audit starts at US$1,000, with up to nine assessment hours including setup, investigation and reporting, plus a separate one-hour walkthrough. We agree the scope before quoting. A larger codebase, more repositories or deeper testing can require a separate quote. This is Ekyon's offer, not a market-wide price estimate.

Does the audit price include fixing the code?

No. The audit covers assessment and a repair plan. Your team can use that plan, or we can quote an agreed repair scope separately. Fixes and any follow-up verification must be named in that scope.

Is nine hours enough, and what if the app cannot be run?

Nine assessment hours support a narrow question in a tractable app, not every path in a whole system. Setup and reporting are included in that budget. If missing access or setup blocks useful review, we flag it and agree a narrower question or revised scope before additional work. Unavailable evidence is reported as not assessed.

Who reviews the code, and how are tools and access handled?

A senior engineer, named in the proposal, after we confirm your stack is a fit. We agree confidentiality, permitted tools including any AI services, code or evidence sharing, retention and access removal before access is granted. The reviewer interprets tool results and records the evidence supporting each finding.

What if you find nothing serious?

The report records what was assessed, useful controls actually observed and what remains unknown. There is no required finding count or whole-product safety grade. Your existing engineer can implement the repair plan; buying implementation from Ekyon is optional.

Can you audit an app built with Lovable, Bolt, Replit, Cursor or Claude?

Yes, subject to confirming the stack, access and scope. The review looks at what the software does and where the risks are, regardless of who or what wrote it: often access rules, keys in the browser, paid features and database permissions. Share the stack and the flows that matter first so we can confirm fit.

How do we share code and how long does the review take?

Agree the confidentiality arrangements and scope before granting least-privilege repository access. Do not send passwords or production secrets with the first enquiry. Runtime access or testing needs separate authorisation. Plan for one to two weeks after scope, access and a start date are confirmed; we agree the actual schedule in the proposal.

Will an audit certify that our software is secure or ready to launch?

No. A scoped audit can identify risks and support a launch or handover decision. It cannot guarantee that software has no vulnerabilities. Penetration testing, formal technical due diligence and compliance certification are separate scopes, not automatic parts of this offer.

Know what to fix before your next step.

A focused code audit from US$1,000, scoped in writing first.