Skip to main content
Find out what can stay, what must change and whether the project is ready for responsible development

Audit and takeover of an application built with AI

We review the code, data access, permissions, integrations and deployment of applications created with AI coding tools. The result is an evidence-based plan for repair, takeover or rebuilding.
Illustrative view of a Domin Software specialist and a client reviewing application flow diagrams

Illustration of a joint review of application flow diagrams.

You may have a working prototype built in Lovable, Bolt, Replit, Cursor or another AI-assisted tool. Forms save data, sign-in appears to work and the product is ready for a demonstration. The difficult questions arrive when payments must be connected, real users are invited, another regression appears, or somebody has to maintain the application.

You do not need to know the programming language or architecture for the first conversation. Explain what the application does, what already works and where progress stopped.

What do you receive?

  • a description of the application, technology and important dependencies,
  • prioritised findings with evidence and operational impact,
  • urgent actions concerning access, data or exposed secrets,
  • a clear record of what can be retained,
  • a recommended direction and scope for the first implementation stage,
  • handover material that remains useful even if another supplier performs the work.

When is an audit useful?

The prototype works, but production readiness is unclear

A preview environment does not prove that configuration, data access, failure handling, backups, monitoring and rollback are ready for customers.

Every change creates another fault

A screen change breaks sign-in, a new field spreads across unrelated files, or the generator creates duplicate versions of the same feature. The cause may be local, but it may also be missing structure or tests.

The application already handles users, data or payments

At this point, appearance is not enough. Roles, server-side authorisation, tenant separation, webhook verification, retries and interrupted operations all affect the risk.

The original creator cannot continue

Documentation, deployment instructions and access ownership may be incomplete. Before taking over, we establish what exists in the repository and external services and whether the environment can be reproduced.

A working screen does not reveal the whole risk

Consider a subscription application where a user can create an account, choose a plan and pay. The happy path still does not tell us whether users can read only their own records, whether the server verifies the payment provider’s signature, what happens when the same event is delivered twice, or whether an exposed secret has been revoked.

This is a hypothetical example, not a claimed client project. It illustrates why a review also covers missing data, unavailable third-party services, different user roles and repeated operations alongside the successful path.

How does the review proceed?

  1. Qualification. We establish the purpose, technology, environments, data and current obstacle, then confirm whether the project fits our competence.
  2. Safe access. We agree the repository, configuration and technical accounts needed. Passwords and API keys are not sent in an ordinary message; read-only access is preferred when it is sufficient.
  3. Paid discovery. We run the project in a controlled environment, inspect critical paths and document issues with evidence and impact.
  4. Decision options. We show what can stay, what is urgent and what would be safer or less costly to replace. Any implementation becomes a separate, testable scope.

What does the audit cover?

What does the audit cover?
AreaWhat we inspectWhat the finding changes
Setup and dependenciesWhether the project can be reproduced, required services and packages, and the location of configuration.Shows whether another developer can work without reconstructing the environment by trial and error.
Authentication and permissionsSign-in, roles, server-side operations and separation of user or tenant data.Distinguishes a hidden button from genuine access control.
DataSchema, migrations, backups, deletion, imports and transfers to external services.Reveals risks of loss, mixing or unintended disclosure.
Integrations and paymentsKeys, webhooks, signatures, retries, limits, failures and state consistency.Shows whether interruptions or duplicate events create double operations or incorrect status.
Code and testsStructure, duplication, coupling, error handling and protection of critical flows.Indicates the likely cost and risk of future changes.
Deployment and operationsRelease process, pre-change backup, logs, monitoring and rollback.Determines whether the application can be responsibly maintained after takeover.

A small internal tool needs a different depth of review from a public multi-tenant service with payments. We select the checks that actually affect the owner’s decision.

Four possible outcomes

Keep

The core is understandable and predictable. Focused fixes, critical tests or deployment improvements are enough.

Stabilise

The application works, but further features would magnify risk. Dependencies, data handling and releases come first.

Replace one module

Most of the project can remain, while authentication, payments or the data-access layer needs a separate implementation.

Build a new version

The prototype validated the workflow, but its code offers no sensible maintenance path. Its screens and process knowledge still inform the new product.

Security needs context, not just a scanner

Not every identifier visible in a browser is a secret key. We check what access it grants and which controls the server or database enforces. Administrative keys, broad-access tokens and webhook-signing secrets do not belong in public code. An exposed secret must be revoked and replaced; deleting it from a file is not enough.

Automated tools help find known patterns, vulnerable dependencies and accidentally committed secrets. They do not resolve business logic. We combine their findings with manual checks of data flows, permissions and application behaviour, following the approach described in OWASP Secure Code Review and NIST Secure Software Development Framework.

A suspected active leak or account compromise needs an incident response rather than an ordinary development audit. Access must first be contained, credentials changed and a way to preserve evidence agreed. Further work depends on the data and the effects of the incident.

Scope boundaries and use of AI

The standard review is not a security certificate, a complete penetration test or legal advice. We can identify technical data flows and controls relevant to a later privacy assessment, but we do not replace the controller’s legal analysis. If a separate security review is needed within a defined scope, see the web application security audit. We also qualify the technology before promising a takeover; an unfamiliar stack may require another specialist.

AI tools can help trace dependencies or organise material, but a person remains responsible for the conclusions. We agree how external services may be used before a repository is shared. Client code, configuration and data must not go to a public model without an informed decision and agreed processing rules.

If the review must avoid external models, tell us at the start. We will adapt the process and tools to that requirement or explain which environment is missing.

Frequently asked questions

Is an audit useful before the first public release?

Yes, particularly before real payment, personal or multi-tenant data enters the system. Access and deployment are usually easier to correct at that stage.

Can you assess an application without repository access?

We can perform an initial review of visible behaviour and define the access needed. A reliable assessment of code, dependencies and deployment requires source access in an agreed form.

Can you take over development afterwards?

Yes, if the technology and project condition fit the agreed scope. Further development is priced and accepted as a separate stage.

Does the audit guarantee that no vulnerabilities exist?

No. It reduces uncertainty within the agreed scope and records the issues found; it cannot guarantee discovery of every possible vulnerability or future defect.

What should you send first?

Explain what the application does and what prevents release or development. Name the tool or technology if you know it. Mention existing users, payments or personal data and whether you have a repository.

Describe the application and the problem in the form. We will agree how to share documentation, screenshots or other files after you contact us.

Do not send passwords, API keys, production database copies or customer data. We first assess whether we can quote for a specific fix or need a separate paid investigation and an agreed way to share repository access.

A wider project may continue as application modernisation or development takeover. Our guide to changing developer for an existing application provides a useful preparation checklist.

Technical references

Describe your project

Describe what you want to build or what is not working. Include the programs you use and the outcome you need. You can paste an existing description or summary.

Fields marked with * are required.