Measure this visit?
Accept allows Google Analytics, Microsoft Clarity and PostHog, including session recording. Reject stops their recording. Cookieless counts and server request logs stay on. What we measure
Growth & Demand
You built it with AI and it works. We harden auth, payments and data in the code you already have, then take it live and into its first channel.
Updated
Your app works. Most people never get that far, so take the win.
What is missing is one layer. It runs for you and three friends. It is not yet something a stranger can sign up for, pay for, and trust with their data while you are asleep. That layer is what this service covers. We read the code you already have, then fix auth, data isolation, payments, performance and deployment in place, then run the launch. It is not a rebuild. If you want it built from nothing, that is our software development engagement under Build and AI, a different scope and a different timeline. If what you want is an AI feature that does not exist yet (designed, evaluated and built into the product), that is AI integration. That work is open-ended engineering and this one is a bounded pass. Sustained demand after launch is the SaaS growth service. This page ends at live, paid for, and measured.
We start by reading the repository. Not scanning it. Reading it.
AI coding tools are good at producing the thing that was described to them. They are weaker at the parts nobody describes, because nobody prompts for the second click, the hostile user, or the refund. Those gaps come from how the code was produced. So this runs off a fixed checklist instead of a hunch.
The first thing we look for is a route that checks whether you are logged in and never checks whether the record belongs to you. Change the id in the URL and you are reading someone else’s data. Broken access control is A01 in the OWASP Top 10:2025. That is a reason to test ownership checks explicitly. The prompt said “let users see their orders”, and the happy path satisfies that sentence completely.
Close behind it, three more. Row-level policies left permissive on a hosted database. An admin screen guarded only by hiding the button. A service credential shipped in the client bundle, where view-source reads it.
Prices decided in the browser can be edited in the browser. Webhooks that are not signature-verified will accept a forged “payment succeeded” from anyone who finds the endpoint. Fulfilment that is not idempotent will grant the plan twice when the provider retries, which providers do by design. We wire checkout so card details never touch your server, verify every callback and make fulfilment safe to repeat. Then we test the paths nobody builds first. Failed card, refund, cancellation, and the customer who pays twice in four seconds.
We establish where personal data actually lives and whether the backups restore or merely exist. Then whether logs are printing tokens, and whether a user who asks to be deleted can be. These are cheap to fix before launch and unpleasant afterwards.
If the app talks to a language model, this section starts with the key and nothing subtler. A provider credential left in the client bundle is the cheapest attack there is. View-source, copy, spend. The meter runs in your name until somebody notices. A bug that only embarrasses you is one thing. This one costs real money while you sleep, so it gets checked before anything clever does.
From there the pass answers five questions in writing and stops there. Is the key on the server, or in the bundle. Is there a ceiling on what one account can spend in a day. Does the call time out, or does it hold a request open until something upstream gives up. If the model can reach tools or your database, what is the worst thing a hostile input could talk it into doing. We report that blast radius and close the obvious doors. We do not redesign the feature around it. And what does the model cost per active user, because that number decides whether your pricing survives contact with usage.
That is triage: bounding and securing a feature that already exists, inside a time-boxed pass over the code you already have. Sometimes the read says the feature needs designing instead. An eval set so you can tell whether a prompt change helped. Schema validation on every output. A defined degraded mode for the hours your provider is down. That is a build, and it is our AI integration service. We tell you which of the two you are buying after reading the code. Saying it then beats letting you pay for the wrong one.
Queries that are instant against fifty rows are not instant against fifty thousand. We find the missing indexes and the loops issuing one query per item, and set up error tracking. A failure then reaches you before it reaches a review.
Your architecture survives unless it is the actual problem. The framework your tool chose, the database it picked, the naming, the structure: all of it stays if it works. We change the smallest number of things that make the app safe to sell. You should still recognise the repository when we hand it back. You built this. We are making it durable, not making it ours.
Going live is a step, not a finish. We ship it behind a rollback, watch the first real traffic, and open exactly one acquisition channel with measurement that works on the first visit. One channel, properly instrumented, tells you something true in a fortnight. Five channels opened at once tell you nothing for a quarter, and cost more doing it.
A working app does not get rewritten into a stack we happen to prefer so that we can bill you for the translation. Nor do you get a findings document and a wave goodbye. An unimplemented fix is not a fix. Nobody here will tell you the app is now secure, because that sentence is not available to anyone about any software. What we can tell you is which classes of defect were found, fixed and tested, and which we did not go looking for.
And the launch waits if the payment or deletion path is untested. Failures on those two cost trust, and a discount does not buy it back.
We read the repository before proposing anything. The risk in an AI-assisted build is rarely where the owner expects it. A quote written without reading the code is a guess that you pay for later.
Anything that lets one user reach another user's data or another user's money goes first. A scanner sorts by CVSS score. We sort by what actually happens to you and your first customers if it fires.
Payments, refunds, deletion and backups are the paths where a bug is expensive and irreversible. We test them against real failure cases, including the double-charge and the restore, before anyone is invited in.
Split environments, migrations that run in order, and a deploy that reverses in one step. Error tracking that tells you it broke before a customer does. Launching without this is the expensive kind of brave.
We launch into a single acquisition channel with tracking that survives ad blockers. The first weeks then produce a readable answer about demand, and not five untracked experiments and a feeling.
Only if the code argues for it, and at whole-app scale it almost never does. A rewrite discards the parts that were already correct along with the parts that were not, and you pay to re-derive both. When we do recommend replacing a component, we show you the code that drove the recommendation and the cost of both paths, and you decide.
It is differently insecure. It produces the paths that were prompted for and skips the ones nobody thinks to ask for. Ownership checks on a route that already checks login, rate limits, deletion, what happens on the second click. Broken access control is the top category in the OWASP Top 10, and that is exactly the class of bug an unprompted generator leaves behind.
We work in what you have. Framework, hosting and database stay unless one of them is the actual defect, and we will say so plainly if it is. Rewriting a working app into our preferred stack would bill more hours and deliver you less.
No, and the handover is written for exactly that. You get the tests, the environment setup, and a short list of the invariants you should not break while prompting. Nothing in that handover is arranged so that you have to come back to us. The only difference afterwards is that a bad change fails in staging instead of in front of a customer.
We need the repository and a non-production environment to start. For the payment and data work we need scoped keys to a test project, not your live keys. If production access is unavoidable for a specific fix, we say which fix, for how long, and you rotate that credential afterwards.
It depends on what the review finds, which is why the review comes first and is quoted separately from the work. A prototype with clean boundaries and a single payment path is a very different job from one with a service key in the browser bundle. We give you a fixed scope after reading the code, not before.
That is a real outcome and we will not pretend otherwise. Taking an app live proves it works, not that anyone wants it. The launch is instrumented so that a negative result is legible within weeks. The alternative is guessing at it for a year. Sustained demand work is a separate engagement, and you should only buy it once the signal exists.
Start a conversation