Learn
The agency software revenue calculator: how to package AI-built apps
Software is the only agency deliverable that bills every month it exists. Here is the packaging model, the four numbers that drive it, and how to run the math for your own client base.
Agency software revenue is a function of four numbers: clients served, package price, delivery cost per build, and the monthly operate fee that turns a project into recurring income. Unlike campaign work priced on hours, AI-built software is priced on outcome and retained on subscription — a portal built once bills every month it runs. This article turns those four inputs into a packaging model and an annual revenue framework you can defend to your own board.
Published 2026-07-03 · Last updated 2026-07-03 · Ciao editorial team
The short answer, expanded
Agencies price almost everything on effort — hours, retainers, headcount — because effort was the constraint. AI-assisted engineering breaks that link for software: when a client portal takes days of platform-assisted work instead of months of engineering payroll, pricing it on effort means donating the margin the new economics just created. The correct basis is value and packaging: what is the operational problem worth to the client, and what fixed, repeatable offer wraps it?
The model that works is deliberately unoriginal, because it is the productized-service model agencies already understand. A fixed-scope build fee gets the software live; a monthly operate fee keeps it hosted, monitored, maintained and improving; an expansion path — more modules, more seats, more locations — grows the account without a new sales cycle. What is new is only the input cost: the delivery loop (testing, security, governance, deployment) comes from the platform rather than from staff, which is what makes the margin structure work at agency scale.
One honesty note before the arithmetic: every number in this article is an illustration, not a promise. Rates vary wildly by market, niche and positioning. The point of the framework — and of the interactive calculator it feeds — is that you plug in your numbers and defend the result, not that you borrow ours.
The revenue problem this solves
Agency economics have a rhythm every owner knows: sell, deliver, invoice, and start the next quarter at zero. Retainers soften it, but retainers are bought scrutiny — renegotiated annually, benchmarked against cheaper competitors, first on the block when the client's budget tightens. The structural weakness is that most agency deliverables stop working when the agency stops working. A campaign ends. A portal does not.
That is why the operate fee, not the build fee, is the strategic half of software packaging. Software that runs a client's daily operation — their customer portal, their booking flow, their reporting — creates the stickiest commercial relationship an agency can hold, because cancelling it means the client switching off a tool their own staff and customers use every day. Agencies that added a software line report the same pattern: the build fees are nice, and the compounding monthly base is what changes the business's valuation.
Valuation is worth dwelling on for owners thinking about exit. Agencies trade on multiples that discount project revenue heavily, because it walks out the door every quarter; recurring software revenue with low churn is valued on an entirely different basis. A modest operate base — a few dozen clients paying monthly for software they depend on — can change how an acquirer models the whole business. That is a second-order effect of packaging decisions made in year one, which is why the operate fee deserves board-level attention rather than an afterthought line in a proposal.
The other half of the problem is that agencies already generate software demand and hand it away. Every process pain a client mentions in a status call is a software brief in disguise. Packaging is what converts those moments into revenue: when there is a named offer with a fixed price on your rate card, "you should fix that" becomes "we can fix that — it's the Launch package."
The four inputs that drive the model
Every agency software P&L reduces to these. Estimate each conservatively before touching the calculator — conservative inputs that still produce an attractive model are the signal that the offer is real rather than hoped for.
- 1. Clients served per year — Not your total client list — the number you can realistically sell and deliver software to in year one. Most agencies start with three to six friendly accounts where trust already exists, then let referrals compound. Capacity grows fast once builds become repeatable.
- 2. Package price (the build fee) — Anchor on the client's alternative, not your effort: a custom portal from a dev shop is a five- to six-figure engagement, and a template tool is a compromise they have usually already rejected. Fixed price, fixed scope, named exclusions — priced like the productized offer it is.
- 3. Delivery cost per build — Your platform commitment amortized across builds, plus the account and production time your team spends scoping and iterating. This is the input AI-assisted engineering transforms — the platform carries the testing, security and deployment work that used to be payroll.
- 4. Monthly operate fee — The subscription for hosting, monitoring, small changes and a periodic improvement cycle. Set it high enough to fund real attention — this fee is your retention engine, and underpricing it is the most common packaging mistake agencies make.
The three-tier packaging model
A structure agencies adapt to their niche. Prices are deliberately omitted — set them from your market position using the four inputs above. The tier names matter less than the boundaries between them, which is where margin either survives or leaks.
| Package | What the client gets | Commercial shape | What it does for the agency |
|---|---|---|---|
| Launch | One scoped application — portal, dashboard or booking tool — live, tested and branded | Fixed build fee, defined scope, 30-day warranty window | The entry product: proves the offer, creates the operate relationship |
| Operate | Hosting, monitoring, security checks, small changes and a quarterly improvement session | Monthly fee, annual term, change budget defined in days or requests | The recurring base: retention, predictable revenue, monthly client contact |
| Scale | New modules, integrations, additional user groups or locations on the existing app | Per-module fixed fees or an expanded monthly tier | Account growth without a new-logo sales cycle |
Run your own numbers
Twenty minutes with a spreadsheet — or the interactive agency revenue calculator, which walks these same steps. Bring the output to your leadership as ranges, not points.
1. Count the demand you already saw
List every software-shaped request from the past twelve months — portals, dashboards, intake tools, integrations you declined or referred out. That list, not a market report, is your year-one pipeline estimate.
2. Price one package against the client's alternative
Take the most common request and price it as a fixed package against what a dev shop would quote and what the pain costs the client monthly. Set the operate fee as a meaningful fraction of build price, annualized.
3. Model a conservative year
Multiply: builds you will actually deliver, times build margin, plus the operate base accumulating each month a client stays live. Run it again at half your assumed win rate to see whether the offer survives pessimism.
4. Check the compounding view
Extend to three years with modest churn. The insight the model always surfaces: the operate base grows into the dominant line, because it accumulates while build revenue resets — which should shape how hard you defend the monthly fee in negotiation.
5. Stress-test delivery capacity
The binding constraint is rarely demand; it is how many builds your team can scope and manage in parallel. Fleet visibility and platform-carried QA are what raise that ceiling — factor them in before promising dates.
Packaging principles that protect margin
Four rules keep the model healthy. Fix the scope, not the hours — the moment a package becomes time-and-materials, you are a dev shop with worse rates. Productize ruthlessly — the second and tenth portal should reuse the thinking of the first, which is where the real margin lives. Never bundle the operate fee into the build price "for free" — a client who pays nothing monthly values the running software at exactly that. And keep expansion pre-priced — when the client asks for the next module, the answer should be a line on the rate card, not a proposal cycle.
One more, learned the hard way by agencies before you: put the quality evidence in the client's monthly report. Test runs passed, security checks green, uptime, changes shipped. It takes minutes to include, and it quietly answers the question every client eventually asks — what am I paying for monthly? — before it gets asked in a renewal meeting.
Finally, resist the two pricing temptations that erode the model from opposite ends. Discounting the build fee to win the deal teaches the client that the software was cheap, which poisons every expansion conversation; if you need to invest in a strategic account, invest visibly — a named discount with a stated reason — so the rate card survives. And resist scope generosity inside the operate fee: the monthly change budget is a feature of the package, not a suggestion, and the Scale tier exists precisely so that growth requests become revenue instead of margin leaks.
Where Ciao fits
Ciao is the delivery engine under this model. Builds are real React, TypeScript and Supabase applications with 100% code ownership — an asset in the deal, not a template subscription — and the platform carries the engineering disciplines the operate fee promises: QA runs deterministic browser replays with smoke gates before publish and production checks after; Security confirms vulnerabilities against the live app before flagging them; Guardrails records review and leaves an audit trail behind every merge, which is the evidence file for your client reporting. Conductor gives one screen across the whole client fleet — the capacity ceiling raiser from step five.
Commercially, the platform is a known input for your model: serious development programs start at USD 10,000 per year, which the arithmetic above typically absorbs within the first engagement or two. The Agency Build Grant reduces the cost of proving the offer on your first real client project. Run your numbers in the agency revenue calculator, then bring them — and one live client brief — to a conversation with sales.
Frequently asked questions
What should an agency charge for an AI-built client portal?
Anchor on the client's alternatives, not your build time: custom development quotes for comparable portals and the monthly cost of the problem going unsolved. Most agencies land on a fixed build fee well above their old project average with margin to spare, because the reference price was set by engineering-payroll economics you no longer carry.
How big should the operate fee be relative to the build fee?
Common practice lands the annualized operate fee at a meaningful fraction of the build price — high enough to fund real monitoring, small changes and a quarterly improvement cycle rather than passive hosting. Underpriced operate fees are the most frequent packaging mistake, because they starve the retention engine the whole model depends on.
Do clients accept subscription pricing for software an agency built?
Yes, when the fee visibly buys ongoing value: uptime, monitoring, security checks, small changes and improvement cycles, reported monthly. Clients already pay subscriptions for dozens of tools; what they resist is a fee attached to nothing, which is why the evidence-in-the-report habit matters.
What happens to the model if a client wants to own everything outright?
It still works — ownership is the point. Ciao output is standard React, TypeScript and Tailwind with 100% code ownership and export at any time, so you can sell full ownership transfers as a premium option while most clients keep the operate relationship because they want the outcome, not the code.
How many builds can a small agency actually deliver in parallel?
The constraint is scoping and client management rather than engineering, since the platform carries testing, security and deployment. Teams of two or three account-side people commonly run several builds concurrently once the package is repeatable; Conductor-style fleet visibility is what keeps the operate base manageable as it grows.
Where does the Agency Build Grant fit into the math?
It reduces the cost of the riskiest build — the first one — by supporting a real client project as you stand the practice up. That effectively shortens the payback period on the platform commitment, which is exactly the variable a cautious model wants de-risked. Sales can walk through eligibility with a live brief.