Skip to content
BuildVettedBy Rohit

Review scope

What we check in a launch-readiness review

A BuildVetted Launch Readiness Review considers nine founder-risk areas: account access and automated abuse, permissions and customer-data boundaries, public attack surface, payments and reconciliation, realtime state and concurrency, scheduled jobs and automation, secrets and third-party trust boundaries, failure visibility and recovery, and founder control and production ownership. Each area below states what is reviewed, why it matters, how it typically fails, what evidence is requested, and what is deliberately out of scope.

This is a scoped launch-readiness review. Applicable paths depend on how your app handles accounts, customer data, payments, integrations and production operations.

Written and reviewed by Rohit · Last reviewed 27 August 2026

Area 01

Account access and automated abuse

Can a script hammer my signup, login or reset flow?

What is reviewed. Throttling on login, signup, password reset and one-time codes; whether limits apply per source and per identifier; how the app responds to repeated failures; whether automated account creation is constrained; whether expensive operations (emails, SMS, AI calls, exports) can be triggered in a loop; and whether any of this raises an alert.

Why it matters. Without rate limits, one script can make thousands of requests, test leaked passwords, create fake accounts or repeatedly trigger actions that cost you money. None of that requires anyone to know your product exists — automated traffic finds public addresses on its own.

Example failure modes

  • Unlimited password attempts, so leaked credentials from elsewhere can be tested against your users at speed.
  • Rate limiting applied per IP only, so rotating addresses bypasses it entirely.
  • Signup with no verification, letting a script create thousands of accounts that inflate usage and cost.
  • A per-request AI or SMS call with no cap, turning a loop into an invoice.
  • Nothing alerts anyone while any of the above is happening.

Evidence that may be requested

  • Rate-limit and lockout configuration, if any exists
  • Two test accounts you create and control
  • Which public actions incur a per-call cost
  • Any existing alerting on failed logins or signup spikes

Not covered

  • Running a credential-stuffing campaign against your live users
  • Denial-of-service or load testing of any kind
  • Testing with real leaked credential datasets
  • Bot-mitigation product selection or configuration

Area 02

Permissions and customer-data boundaries

Can one customer see another customer's data?

What is reviewed. What each role is permitted to reach, checked through the normal interface and through direct requests to the server. Record ownership between accounts, teams or tenants, including database-level rules such as row-level security where the platform provides them. Verified with controlled accounts you own.

Why it matters. Signing in proves who someone is. It does not decide what they may reach. Most quiet data exposure lives in that gap, and the interface usually hides it — the button was removed but the underlying request still works. This is the failure you cannot undo quietly.

Example failure modes

  • Changing an identifier in a request and receiving another account's record.
  • A control hidden in the interface while the endpoint behind it still succeeds.
  • Row-level security switched on with a policy that matches every row.
  • A list filtered in the browser rather than in the query, so the full set is still sent.
  • File or attachment URLs that are guessable and need no sign-in.

Evidence that may be requested

  • Two or more test accounts at different privilege levels
  • Role and permission matrix, however informal
  • Read-only view of database access policies
  • Storage bucket or file access rules

Not covered

  • Exhaustive enumeration of every route and parameter combination
  • Access to or extraction of real customer data — reviews use test data only
  • Privilege escalation against third-party infrastructure

Area 03

Public attack surface

What can a stranger reach without logging in?

What is reviewed. Public API endpoints and what they return; guessable file or storage URLs; forgotten admin, debug or preview routes; webhook endpoints that accept unsigned requests; internal operations callable without going through the intended interface; error responses that reveal internal detail; and whether input is validated on the server rather than only in the browser.

Why it matters. Anything reachable without a session is reachable by everyone, including automated scanners that arrive within hours of a domain going live. The interface is not a boundary — the server is.

Example failure modes

  • A debug or admin route left deployed and reachable by URL.
  • A webhook endpoint that processes anything posted to it, signed or not.
  • An internal action (issue credit, change a role, export data) callable directly.
  • Stack traces or database errors returned to the caller.
  • Validation enforced only in the browser, so a direct request bypasses it.
  • Uploaded files served from predictable URLs with no access check.

Evidence that may be requested

  • List of public routes and endpoints, if one exists
  • Webhook endpoint configuration
  • Storage and file-serving configuration
  • The deployed client bundle, which is already public

Not covered

  • Formal exploit campaigns or proof-of-exploit development
  • Exhaustive injection testing across every parameter
  • Network or infrastructure penetration testing
  • Scanning or testing systems you do not own or control

Area 04

Payments, balances and reconciliation

Can money and access ever disagree?

What is reviewed. Payment states beyond success — declines, additional authentication, cancellation, refunds, partial refunds and the confirmation that never arrives. Whether fulfilment is idempotent when the same event arrives twice. Rounding and precision on stored amounts, currency-code normalization, whether every movement lands in a ledger, whether manual or off-ledger adjustments exist, and whether anything reconciles against the provider.

Why it matters. A green checkout screen proves only one path. The expensive failures happen when money and access disagree quietly — the customer is charged and never gets access, or a retried event grants the same purchase twice, or a balance is restored from a stale snapshot.

Example failure modes

  • Payment succeeds, the confirmation event is missed, access is never granted.
  • The same provider event processed twice, unlocking or crediting twice.
  • Amounts stored as floating point, so a small balance reports as zero.
  • Mixed currency codes treated as interchangeable.
  • A manual balance adjustment made outside the ledger, later overwritten or clawed back.
  • Refunds and cancellations that never revoke the access they paid for.
  • Nothing that periodically compares your records against the provider's.

Evidence that may be requested

  • Test-mode provider access (read-only)
  • Webhook configuration and a recent delivery log
  • How amounts and currencies are stored
  • Whether a ledger exists, and how manual adjustments are made
  • A description of what each payment outcome should unlock

Not covered

  • Testing with real cards or real customer money
  • Tax, invoicing, accounting or chargeback-dispute advice
  • PCI compliance certification
  • A full financial audit of historical transactions

Area 05

Realtime state and concurrency

Is the customer looking at the current truth?

What is reviewed. How the interface handles updates that arrive out of order or more than once; whether a stale snapshot can overwrite newer state; reconnect and resubscribe behaviour after a dropped connection; what happens when two operations touch the same record simultaneously; whether conflicting writes are detected; and whether sequence or version numbers exist to order events at all.

Why it matters. The real balance changes, but the customer keeps seeing a four-hour-old value because an older update overwrote a newer one. Nothing errored, nothing alerted, and the number on screen is simply wrong — which is indistinguishable from theft, from the customer's side.

Example failure modes

  • An older update applied after a newer one, reverting the displayed value.
  • A duplicate message applied twice, double-counting a change.
  • A snapshot fetched on reconnect that silently replaces fresher local state.
  • Two concurrent transactions both reading the old value and both writing.
  • Frontend state drifting from server truth with no mechanism to resynchronise.
  • No sequence or version field, so ordering cannot be established even in principle.

Evidence that may be requested

  • How realtime updates are delivered and subscribed to
  • Whether events carry a sequence, version or timestamp
  • Transaction and locking approach for concurrent writes
  • Reconnect behaviour after a dropped connection

Not covered

  • Distributed-systems formal verification or consensus proofs
  • Load testing to induce contention at scale
  • Rewriting your state-management architecture

Area 06

Scheduled jobs, retries and automation

Can a background job quietly corrupt my data?

What is reviewed. Whether scheduled jobs are safe to run twice; what happens when one fails halfway; whether retries are safe or compounding; whether execution is locked so two instances cannot overlap; how expiry and time-to-live rules are defined and what they actually cover; what reconciliation jobs compare and correct; whether bulk corrections can be dry-run before they write; whether failures alert anyone; and whether an automated change can be reversed.

Why it matters. Automation multiplies whichever logic you give it — the fix or the bug. A job that runs nightly and is subtly wrong is worse than a bug that happens once, because it applies itself consistently and looks like normal operation. Example: a daily reconciliation job sums the wrong transaction types and “corrects” already-correct balances every night.

Example failure modes

  • A job that is not idempotent, so a retry applies the same change twice.
  • Two instances of the same job overlapping with no lock.
  • A partial failure leaving half the records updated and half not.
  • An expiry or TTL rule applied to a key that means more than intended.
  • A bulk correction run straight against production with no dry-run.
  • Silent failure — the job stops running and nobody notices for weeks.

Evidence that may be requested

  • List of scheduled jobs and what each is for
  • Job execution history or logs, if retained
  • Locking, retry and idempotency approach
  • Any expiry, TTL or cleanup rules and what they apply to
  • Whether a dry-run mode exists for corrective jobs

Not covered

  • Running your jobs against production on your behalf
  • Rewriting or re-architecting the job system
  • Auditing every historical job execution

Area 07

Secrets and third-party trust boundaries

Is a privileged key reachable from the browser?

What is reviewed. Where API keys and tokens live; which are designed to be public and which are not; whether any privileged credential is reachable from the browser bundle or a public repository; whether inbound callbacks from third parties are authenticated; and how much a compromised integration could reach.

Why it matters. Platforms deliberately ship two kinds of key. A publishable key in the browser is normal and safe when the access rules behind it are correct. A secret or service-role key in the browser bypasses those rules entirely — it is the master key, handed out with the page.

Example failure modes

  • A service-role key present in client-side JavaScript.
  • A publishable key relied on for protection while the access policies are permissive.
  • Credentials committed to git history and still valid.
  • An inbound callback trusted without verifying it came from the provider.
  • One shared key used everywhere, so rotating it means an outage.

Evidence that may be requested

  • Environment variable names (values are never requested)
  • The deployed client bundle, which is already public
  • A list of third-party services in use and what each can reach
  • Callback and webhook authentication configuration

Not covered

  • Auditing the security of the third-party providers themselves
  • Reviewing secrets you do not disclose or that sit outside the agreed scope
  • Any request for the secret values themselves

Area 08

Failure visibility and recovery

Would I find out before a customer tells me?

What is reviewed. Whether errors are captured in the browser and on the server; whether they carry enough context to trace one request and identify the release; whether anything alerts a human; whether a previous release can be restored; whether backups exist and how recent they are; whether a restore has ever been rehearsed; and who is authorised to make the rollback call.

Why it matters. An uptime check proves the server answered. It says nothing about a customer who signed in, hit an error and saw a blank screen. And rolling back code is not the same operation as restoring data — a backup nobody has restored is a hope, not a plan.

Example failure modes

  • Client-side errors never recorded, so blank screens are invisible.
  • Logs that cannot be tied to a release, so nobody knows which change caused it.
  • Alerting on everything, so real alerts are ignored.
  • A rollback that reverts code while leaving migrated data in the new shape.
  • Backups configured but never restored, so recovery time is unknown.
  • No named person with authority to decide to roll back.

Evidence that may be requested

  • Read-only access to error tracking or logs, if any exists
  • Recent deployment history and rollback procedure
  • Backup schedule, retention, and evidence of any restore performed
  • Any alert routing currently configured

Not covered

  • Building or configuring a monitoring stack for you
  • Performing a production restore on your behalf
  • Ongoing monitoring after the review window
  • Formal disaster-recovery certification or RTO/RPO sign-off

Area 09

Founder control and production ownership

If this relationship ended tomorrow, do I still have a business?

What is reviewed. Who is the account owner and billing owner for the domain, code repository, hosting, production database, payment provider and any builder platform. Whether you can revoke a contractor's access yourself. Whether production configuration and deployment can be operated without one specific person, and what a platform change would cost you.

Why it matters. This is the risk that is invisible while a relationship is good and decisive when it is not. Ownership means you can remove them; being invited means they can remove you. Some of these can be rebuilt in an afternoon — the domain, the repository and the customer database cannot.

Example failure modes

  • Repository living in a contractor's organisation with the founder as a collaborator.
  • Domain registered on a developer's personal account.
  • Payment provider account owned by an agency, so payouts route through them.
  • One shared login for everything, with no record of who did what.
  • Deployment only possible from one person's machine.

Evidence that may be requested

  • List of every account the app depends on
  • Owner and billing owner for each
  • Who can currently revoke whose access
  • Any handover documentation that exists

Not covered

  • Legal advice on contracts, IP assignment or disputes
  • Negotiating with your contractor or agency on your behalf
  • Performing account transfers for you

Ready to have these nine areas checked on your app?

Fixed scope, fixed price, evidence-backed verdict. Anything that cannot be checked with the access provided is reported as NOT VERIFIED, never assumed to be fine.

Get your app reviewed

Fixed scope · Independent review · No rebuild pitch