Agencies
Turning client builds into recurring software revenue
The project fee is the smallest number in a software engagement. Maintenance, governance, hosting and iteration are the retainer — here is how agencies structure and run it.
A software retainer is a monthly agency engagement covering everything a shipped client app needs to stay alive: hosting, monitoring, maintenance, governed changes and a steady iteration allowance. On Ciao, the operational work is carried by the platform — Doctor monitors live apps, QA gates releases, Guardrails governs changes, Conductor oversees the whole client fleet — so an agency can run software retainers across many clients without hiring an engineering team.
Published 2026-07-03 · Last updated 2026-07-03
The project-fee treadmill, and the way off it
Agencies live and die by a brutal ratio: how much of next quarter's revenue exists yet. Project work resets to zero every time a deliverable ships — new pitches, new scopes, new feast-or-famine. Every agency owner knows recurring revenue is the answer; the hard part is finding recurring work clients happily pay for that does not quietly become unpaid overservicing.
Software is the best answer the agency business has ever had, because software is never finished. A shipped portal or CRM needs hosting that stays up, dependencies that stay patched, changes that get reviewed before they break something, and a steady stream of small improvements as the client's business moves. Unlike a website — touched twice a year — an operational app is used every day, which means its care is visibly worth paying for every month.
The traditional blocker was that operating software required engineers on call, which is exactly the payroll agencies did not want. That is the part Ciao changes: monitoring, testing, security and governance are platform functions rather than headcount. Your team's retainer work becomes judgment — deciding what to improve, reviewing what ships — while the platform does the watching.
What a software retainer sells
Four components, each concrete enough to list on an invoice. Together they answer the client's question — "what am I paying for every month?" — before it gets asked.
Hosting and uptime
The app runs on infrastructure designed to scale — Kubernetes, isolated pods, multi-region support — deployed to Ciao cloud or the client's own account, presented as your managed service.
Monitoring and maintenance
Doctor probes the live app, DNS and CDN, diagnoses root cause and drafts the fix; Security keeps scanning dependencies and access control. Problems get found by the platform, not by the client.
Governed change
Every retainer change passes the same discipline as the original build: Guardrails policy review on risky surfaces, QA replays before publish, an audit trail behind every merge. Month twenty-four is as safe as day one.
Iteration allowance
A monthly budget of improvements — new fields, a report, a workflow tweak — shipped on a predictable cadence with release notes. This is the line item clients renew for.
How a retainer month runs
1. Brief
Collect the month's requests — client asks, Doctor findings, your own roadmap notes — into one prioritized list the client signs off. Fifteen minutes, not a discovery workshop.
2. Build
Work the list in the Builder on branches, with checkpoints and undo making experimentation cheap. The prompt queue keeps a junior productive through the backlog.
3. Review with the client
Changes land in the live preview for client sign-off before merge. Nothing reaches production on an assumption — approvals are recorded, not remembered.
4. Govern
Guardrails reviews anything touching protected zones — auth, payments, data access — and records the human decision. The audit trail is your answer when anyone asks what changed and why.
5. Ship
QA smoke gates run before publish, production checks after. Send release notes: the two-paragraph email that makes the retainer visible is the cheapest churn insurance there is.
6. Retain
Review Doctor and usage findings, roll open items into next month's brief, and flag the larger opportunity you spotted — retainers are where the next project fee comes from.
Retainer shapes that work
Three common structures, in ascending commitment. Platform context: serious agency development programs on Ciao start at USD 10,000 per year, typically amortized across the whole client portfolio.
| Package | Typical scope | Delivery rhythm | Revenue model |
|---|---|---|---|
| Care | Hosting, monitoring, maintenance, small fixes | Monthly release notes; fixes as needed | Flat monthly fee per app |
| Care plus iteration | Care plus a monthly improvement allowance | Fortnightly or monthly releases | Higher flat fee; unused allowance rules set in contract |
| Product partner | Care plus a standing roadmap across several client apps | Weekly cadence, quarterly planning | Monthly program fee, reviewed annually |
Ownership, exits and why clients say yes
The strongest retainer pitch is the freedom not to buy it. Because every Ciao build is standard React, TypeScript and Tailwind — 100% owned and exportable to any repository — the client is never held hostage: they can take the code to another vendor tomorrow. Paradoxically, that is why they stay. A retainer chosen freely renews; a retainer enforced by lock-in curdles into resentment and a rebuild RFP.
For the agency owner there is a longer game: recurring software revenue with an audit trail, documented governance and portable code is exactly the kind of revenue acquirers and lenders value, because it survives due diligence. Run the fleet through Conductor — live health across every client project on one screen — and the retainer book becomes an operated asset, not a pile of favors. New to this motion? Ship the first paying client build with the Agency Build Grant and structure the retainer from day one.
Frequently asked questions
What do we actually do each month if the platform does the monitoring?
You do the judgment work: prioritize the iteration list, review governed changes, sign off releases, and talk to the client. The platform watching the app is what makes those hours high-margin instead of firefighting.
Can we resell hosting as part of the retainer?
Yes. Ciao bills your agency for the platform; the client pays you one monthly fee in which hosting, monitoring and care are your managed service. Apps can run on Ciao cloud or in the client's own AWS, Azure or GCP account if their IT policy requires it.
Who owns the code during and after the retainer?
Whatever the contract says — the platform supports both agency-owned and client-owned structures, and the code is exportable either way at any time. The clean-exit clause is a sales asset: put it in the proposal and watch the objection disappear.
How many client apps can one team realistically operate?
More than headcount math suggests, because monitoring, QA and security run per-app automatically and Conductor gives one screen across the fleet — it is built for hundreds, sometimes thousands, of projects. The practical ceiling becomes client communication, not operations.
What if a client stops paying?
The same clean-exit machinery protects you in reverse: hand over the export, transfer the backend, end the operations service. Because the retainer's value is ongoing care rather than access ransom, ending it is a commercial event, not a legal one.
How do we price the iteration allowance without overservicing?
Define the allowance in outcomes shipped per month, keep the approved list as the boundary, and let anything larger become a quoted project. The monthly brief-and-sign-off step exists precisely so scope creep dies in a fifteen-minute meeting instead of your margin.