Is your vibe-coded AI app ready for paying users?

Add a per-user daily spending cap for AI calls. Before every AI provider call on the server, add up that user's AI cost for today from the database. If it's over the cap (one config constant, start at $2), don't call the provider: return a clear error saying the daily limit was reached and when it resets, and show that message in the UI.

Add rate limiting to every server route or function that calls an AI provider. Limit by user id, and by IP address for signed-out requests, for example 10 requests per minute. Store the counters somewhere shared across server instances, not in memory. Return HTTP 429 with a message saying how long to wait, show it in the UI, and list the routes you protected.

Check that no AI provider key (OpenAI, Anthropic, Google, OpenRouter, Replicate, fal or similar) can be read in the browser. Search the code and env files for keys used in client code or exposed with a public prefix such as NEXT_PUBLIC_ or VITE_. Move every AI call into a server route or server function that reads its key from a server-only environment variable. Then tell me which keys were exposed so I can rotate them.

Find every place the app calls an AI provider and make retries safe: at most 2 retries with exponential backoff, only for timeouts, rate limits and 5xx errors (never for 4xx errors such as bad requests or content-policy refusals), plus a timeout on each call. Make sure the frontend doesn't retry on top of the server. List each call site and what you changed.

List every AI provider this app calls. For each one, tell me where in its dashboard I can set a monthly budget alert or a hard spending limit, and suggest a limit based on our code: which models we call and how many calls one user action makes. Don't change any code.

List every place this app calls an AI provider, including background jobs, query or prompt rewrites, moderation, classification and retries. For each one, tell me whether the user is charged for it and how much, and flag any call that's free by accident. Add a short comment next to each call that's free on purpose saying why, and charge for the rest using our existing credit or usage system.

Move all credit or usage deductions to the server. For each AI action, check the user has enough credits before calling the provider, then deduct only after the result is produced and saved, in the same database transaction as saving it (or reserve the credits first and release them on failure). The client must never send the amount to deduct or write to the balance directly, and database permissions must stop users from updating their own balance.

Make sure users are never charged for a failed AI call. If credits are reserved or deducted before the call, refund them automatically when the call errors, times out, is blocked by the provider's safety filter, or returns an empty or unusable result (for example invalid JSON, a blank image or a cut-off reply). Record each refund with its reason, and tell the user the attempt failed and they weren't charged.

Make AI requests idempotent. Have the client create a unique request id for each user action and send it with the request. On the server, store it with the charge, and if the same id arrives again, return the existing result instead of calling the provider and charging again. Also disable the button that started the request while it's running.

Store every AI result in the database with the feature or step that made it (for example support_reply, invoice_extract or lead_score), the exact model id the provider reported, a prompt version label (for example support_reply@v3), the parameters used (temperature and similar), the input, the user id, timestamps and the provider's request id. Add columns or a JSON metadata field and fill them wherever results are saved. Never store API keys.

When a user retries, edits or corrects an AI result (asks for another try, edits a drafted email, fixes an extracted field, changes a label), never overwrite the original. Save the new version as a new row linked to the same request, with a version number and who made the change, and show the latest version by default. Update any queries that assume one result per request.

Record what happens after each AI result as events in our own database, written by the server. Record the signs that it didn't work: the user asked for another try, undid it, edited or corrected it, asked the same question again, asked for a person, overruled a label or ignored the results. Also record the signs that it did: used, sent, saved, copied or exported. Each event needs the result id, user id, event type and a timestamp. Add the server endpoint, call it from the existing buttons and flows, and don't rely on a third-party analytics script.

Using the stored AI results and their events, work out worked first time: the share of results that needed no retry, undo, edit, correction, re-ask, hand-over or overrule. Add a query or a small admin page showing it per feature, per model and per prompt version, for the last 7 and 30 days, with the number of results behind each figure.

Record the cost of every AI provider call. After each call, save a row with the result or request it belongs to, a step name (for example search_articles or draft_reply), the model id, the usage the provider reported (tokens, images or seconds) and the cost in USD, worked out from one price table in the code. Include retries, so every try is counted.

Using the cost records and the worked-first-time data, add a query or admin page showing, per feature and per model for the last 30 days: total AI spend, wasted AI spend (the cost of results that didn't work, including their retries) and real cost per result (total spend divided by the number of results that worked). Show them next to AI spend as a share of revenue if we record revenue.

Save a few traits with each AI result that might explain failures, without personal data: the input's language, its length in a few bands, the kind of input (for example a scanned or a digital PDF, or the question topic), the user's plan and whether they're new. Then show worked first time split by each trait for the last 30 days, sorted with the groups the AI fails most for at the top, with the number of results in each group.

Move every AI prompt in this app into its own file in the repo (for example prompts/support-reply.ts), each with an explicit version label like support_reply@v3 that gets saved with every result. Replace inline prompt strings with imports. From now on, when a prompt changes, bump its version instead of editing it in place.

Put the model id and prompt version for each AI step behind a setting I can change without a deploy (an environment variable, a database setting or a feature flag), with the option to send a percentage of users to a second variant. Assign variants by user id so the same user always sees the same one, and save the variant on each result.

Add a script that picks real past AI requests from the database (for example 50, mixing results that worked first time and ones that didn't, with personal data removed), saves them as a test set file, and replays them through any model and prompt version I name. It should save the new results next to the originals, with cost, so I can compare them before switching.

List every AI model id this app uses, where each one is used, and whether its provider has announced a shutdown date. Make sure each model id is defined in one place in the config. Then add a short MODELS.md explaining how to switch each step to its replacement and how to test it first by replaying real past requests.