You prototype a client app in a day. The client loves it. Then you do it again for the next client. And the next one. Every time: set up a database, wire up authentication, configure hosting, connect to the client's existing tools, figure out deployment. None of it is hard. But you do all of it from scratch, for every single client.
The problem is not that it takes long. The problem is that you never stop repeating it.
The pattern every agency recognizes
A new client engagement starts. You scope the project: a custom CRM, an operations dashboard, a campaign monitoring tool. Your team can build it fast. Claude Code, Cursor, or your own stack. The code is not the bottleneck.
The bottleneck is everything around the code:
- Database. Where does the data live? Supabase, Neon, a managed Postgres. A new one for every project.
- Authentication. The client wants SSO with Okta or Microsoft Entra. Their IT team requires it. You wire up Auth0 or BetterAuth. Again.
- Permissions. Not everyone should see everything. You build role-based access from scratch. Again.
- Hosting. Vercel, AWS, a VPS. A new account, a new deploy pipeline. Again.
- Integrations. The client uses Salesforce, Slack, Notion, Stripe. You write custom connectors. Again.
5 services. 5 accounts. 5 configurations. Rebuilt from scratch on every engagement.
Your client is paying for a custom CRM. You are spending the first days of every engagement on the same plumbing you set up last month for a different client.
The handover problem
The project ships. The app works. Now comes the conversation nobody enjoys.
The app lives on your Vercel account. The database sits in your Supabase org. Auth is configured under your credentials. The client paid for a product. What they got is a dependency on your infrastructure.
Transferring ownership means migrating across multiple services, re-configuring access, and hoping nothing breaks in transit. Some clients accept the situation and stay dependent. Others push back. Neither outcome is good.
The agencies that win long-term are the ones whose clients stay because the work is valuable, not because leaving is too hard.
The recurring revenue gap
Most agency projects are one-offs. You deliver the app, hand over access as best you can, and move on to the next engagement. There is no structural reason for the client to keep paying after launch.
Retainer work exists, but it is negotiated separately every time. There is no compounding. Your tenth client does not make your eleventh client easier to serve.
This is the pattern: build, deliver, move on. The agency grows linearly, one project at a time.
A different approach: one stack, every project plugs in
The alternative is to stop assembling a new stack for every client.
Instead of 5 scattered services per project, use one shared production stack that handles database, authentication, permissions, hosting, integrations, and AI agent execution. Set it up once. Every new client project plugs into the same foundation.
This changes 3 things at once:
1. You start with business logic on day one.
The database is there. Login and SSO are there. Permissions are there. Hosting is there. Integrations to the client's tools are there. Your team writes the thing the client is actually paying for, from the first hour of the engagement.
The fifth project ships faster than the first because the foundation is already proven.
2. Handover is one operation, not a migration.
The client gets the complete stack: their code, their data, their infrastructure. One transfer. No migrating across services. No re-configuring access credentials across 5 accounts. No dependency on your infrastructure.
The client owns what they paid for. They stay because your work is valuable, not because leaving is complicated.
3. One-off projects become platform revenue.
Every client runs on the same production stack. That stack has a subscription. What used to be a one-off project delivery becomes a project plus a platform subscription underneath.
You keep the retainer for ongoing development. The platform revenue compounds with every new client. Your business model shifts from linear (trade time for money) to compounding (every client adds recurring revenue).
What this looks like in practice
A growth agency delivers custom apps to B2B clients: CRMs built around specific sales workflows, operations dashboards, campaign monitoring tools that pull together outreach activity, intent signals, and LinkedIn ads data.
Before: every project started with the same setup. The same 5 services, assembled from scratch, for every client. Handover was a migration across accounts. No recurring revenue after delivery.
After: 20+ client projects on one shared stack. Every client owns their complete setup at handover. The team writes business logic from day one. Each new project ships faster than the last. Every client pays for the platform.
The infrastructure conversation disappeared. The handover conversation went from the hardest part of every project to the simplest.
The playbook
If you run an agency that delivers custom internal apps, here is the sequence:
Step 1: Pick your next client project. Choose one that is scoped and ready. A CRM, a dashboard, a client portal.
Step 2: Deploy the production stack once. Database, auth, permissions, hosting, integrations. This is not per-project setup. This is the foundation every project will share.
Step 3: Build the business logic. Your team writes what the client is paying for. The infrastructure is already there.
Step 4: Connect the client's tools. Plug in Salesforce, Slack, Notion, whatever they use. The integrations layer handles it.
Step 5: Hand over the complete stack. Code, data, infrastructure. The client owns everything. One operation.
Step 6: Keep the retainer. You built it, you maintain it. The client pays for the platform subscription. You keep the development relationship.
Step 7: Repeat. The next client project plugs into the same foundation. Faster every time.
Why this matters now
AI tools collapsed the time to build. An agency can prototype a client app in hours. But AI did not collapse the time to ship. The infrastructure, deployment, and handover are still manual, still per-project, still the bottleneck.
The agencies that figure out how to industrialize the post-build phase will deliver faster, hand over cleaner, and compound revenue instead of trading time for money.
The ones that keep assembling 5 services from scratch on every engagement will keep wondering why project margins never improve.
RootCX is the production stack that agencies deploy once and plug every client project into. Database, auth, permissions, hosting, integrations, and AI agents: included. Open source, self-hostable, free to start.
Read the full customer story: How a B2B growth agency shipped 20+ projects on one stack.
Top comments (0)