A production-readiness audit for an AI-built app starts at the server
An AI-built app can look finished long before its boundaries are. A polished screen does not prove that a server checks who may read a record, that an error fails safely, or that a clean checkout can build the app.
A useful production-readiness audit starts with requests and failure paths, not screenshots. The goal is not to certify an app as “production-ready.” It is to find assumptions that have not been tested, connect each finding to evidence, and leave a developer with a clear next change.
Start with a map of data and actions
Before opening the code, write down the kinds of users the app supports, the records it stores, and what each user is allowed to do. Include reads, writes, deletes, exports, invitations, administrative actions, and any operation that calls a paid external service.
Then trace each action from its visible control to the server-side handler and the data operation. A hidden button is a user-interface choice; it is not an access-control policy. The browser can be changed, requests can be replayed, and a caller can invoke an endpoint without using the intended screen.
This map helps keep the review concrete. For each action, ask: who is the caller, which resource is involved, which rule grants access, where is that rule enforced, and what evidence shows it works? If the answer is “the client only shows this to the owner,” the server boundary is still unverified.
Test authorization at the object boundary
Authentication answers who signed in. Authorization answers whether that identity may perform this action on this particular object. A valid session does not automatically grant access to every record in the application.
Follow every request that accepts a record identifier from a path, query, header, or request body. Check that the server verifies permission for that specific record and operation. Do not rely on identifier secrecy or an unpredictable ID as a substitute for permission checks. OWASP’s API Security guidance recommends object-level authorization checks in every endpoint that uses a client-supplied object ID.
Turn the access map into tests. Use separate test accounts with different ownership and roles. For each protected read or mutation, test the expected owner, another user, a user with a lower-privilege role, and a request with no valid session. Include negative cases: the response should not reveal protected fields, mutate another user’s data, or fall through to a permissive default.
For database policies, test the policy through the same path the application uses. A policy file existing in the repository is not evidence that the deployed database enforces it. When access should be denied, confirm the result at the server or data layer, not just in the interface.
12 production screens. Login and database wired.
The SaaS Dashboard Kit includes login, a database, and a working dashboard. Live demo at saas.otf-kit.dev.
Follow secrets from source to runtime
Search the tracked files and repository history for credentials, private keys, tokens, and connection strings. Then inspect how configuration reaches the application. A value bundled into browser or mobile code should be treated as visible to users, even if its name includes “secret.”
Use server-side environment configuration for credentials that must remain private. Check ignore rules, deployment settings, build logs, and error output for accidental disclosure. If a credential was committed, remove it from active use and rotate it; deleting the visible line does not make an exposed credential trustworthy again.
Automated secret scanning is useful as one layer, not as proof that a repository contains no secrets. GitHub documents limits around supported patterns and push-protection coverage. A clean scan therefore needs to be paired with a review of the actual secret types and places where the project stores configuration.
Make failure paths visible and safe
Trigger failures on purpose. Try an expired session, a denied request, a missing record, an unavailable dependency, a malformed response, and a component that throws during rendering. Check what the user sees and what the server logs.
A useful failure state explains what the user can do next without exposing stack traces, tokens, query strings containing sensitive data, or internal configuration. A failed authorization check should stop the protected operation. A failed external call should not silently produce a success message or leave a half-updated record.
For each important action, make sure an operator can tell that it failed. Add structured logs or an equivalent diagnostic signal at the server boundary, while keeping secrets and unnecessary personal data out of those logs. Also define how someone can reproduce the failure and identify the affected request.
Prove the project can be rebuilt
A local demo may depend on ignored files, machine-specific paths, uncommitted changes, or a developer’s cached build. Validate the project from a clean checkout in the environment your team uses for releases. Install from the committed lockfile, run the documented checks, and build the deployable artifact.
When a step fails, distinguish a missing prerequisite from a source defect and record the exact command and output. Fix the project configuration rather than adding a path that exists only on one machine. If the app targets mobile, include the real platform build and launch path your team will ship; a web preview is not a substitute for it.
Keep the setup instructions close to the code. Record the required runtime, configuration names without values, migration process, and the checks expected before release. Guidance files for coding agents can help preserve conventions across sessions, but their presence does not replace tests or a security review.
Keep findings actionable
An audit should separate verified defects from questions that still need an answer. For each finding, include the affected route or file, the observation, a reproducible check, the impact if confirmed, and the smallest safe next step. If a claim cannot be reproduced or connected to evidence, label it unknown instead of presenting it as a defect.
Prioritize issues by what an attacker or user can do, not by how dramatic the code looks. A record-ownership failure deserves attention before a cosmetic mismatch. A missing error state may be a reliability concern, while an unverified credential path may need immediate investigation. State the limits of the review: a checklist does not prove the absence of vulnerabilities, and a build that passes does not establish that access policies are correct.
The practical result is a short release decision: what was checked, what failed, what remains unknown, and who owns the next change. For a deeper look at access-control work, see why “just wire up auth” becomes a project plan. Re-run the relevant checks after fixes. That gives the team a trail of evidence rather than a confidence level based on the interface alone.
Sources
- OWASP API1:2023 — Broken Object Level Authorization — accessed 15 October 2026.
- OWASP Authorization Cheat Sheet — accessed 15 October 2026.
- GitHub Docs: Secret scanning detection scope and push protection limitations — accessed 15 October 2026.
- OTF: Why “Just Wire Up Auth” Is a Project Plan Trap — accessed 15 October 2026.
You can explore the OTF kits and live demos when you are ready to begin a project.
Ship the product, not the setup.
- 12 production screens — auth, team, analytics, and settings
- Login and a real database are wired in
- AI configs pre-tuned so your agent extends instead of regenerates
Ship your first screen tonight — free starter in your inbox
The quickstart, the SDK repo and the live kit demos, on this screen and in your inbox.
No spam. Unsubscribe any time.