Dev agency monthly retainer pricing

Dev agency monthly retainers in 2026 price in three structures: hours-based ($8,000 to $30,000+ per month, scoped to a developer's allocated time), capacity-based (X developers reserved at a flat monthly rate), and outcome-based (rare, risk-heavy, hard to scope). Most agencies should run hours or capacity with a $5,000 minimum floor.

The choice between these structures changes your margin, your client churn, and what kind of work you can actually take on. Get the structure wrong and a retainer drains capacity from your project pipeline without paying for it.

What a dev agency monthly retainer actually is

A retainer is a recurring monthly fee that reserves a defined slice of your agency's capacity for one client. The client pays whether they use the hours or not. You commit to availability, response times, and a delivery cadence.

Retainers are not the same as long-running projects. A project has a fixed scope and a finish line. A retainer has an open scope (within a domain) and renews monthly until cancelled. Most agency owners discover this distinction the hard way, after billing four months of "small change requests" against a fixed-bid project.

The three real structures on the market today look like this:

Structure	How it bills	Typical monthly range	Margin profile	Risk to agency
Hours-based	Block of hours (e.g. 40h/mo) at a blended rate	$8,000 to $30,000	40 to 55%	Low. Unused hours expire.
Capacity-based	X developers allocated, flat rate	$12,000 to $60,000	35 to 50%	Medium. You owe availability.
Outcome-based	Flat fee tied to KPIs or deliverables	$5,000 to $40,000	-10 to 60%	High. Scope drift kills you.
Hybrid (base + overage)	Capacity floor + hourly overage at 1.25x rate	$10,000 to $45,000	45 to 60%	Low. Best risk-adjusted option.

The hybrid structure (a capacity floor plus an overage rate) is what most mature shops settle on by year three. It captures the predictability of capacity-based pricing without the margin cliff when a client suddenly needs 30% more work in a month.

Hours-based retainers: the default starting point

An hours-based retainer sells a monthly block of developer time at a blended rate. Forty hours per month at $200/hour is $8,000. Eighty hours at $225/hour is $18,000. You pick a number of hours, a blended rate, and a use-it-or-lose-it policy.

The blended rate matters more than the headline hour count. If your team mixes a senior developer at $250/hour and a mid at $150/hour, your blended rate should be weighted by actual allocation: 60% mid, 40% senior gives you $190/hour. Charge for what you actually staff.

Three operational rules make hours-based retainers profitable:

1. Set a minimum block size of 40 hours per month. Anything smaller costs more in overhead (status calls, ticket triage, context-switching) than the revenue justifies.
2. Track time in 15-minute increments inside Harvest or Toggl. Round up, not down.
3. Sell the hours at a 15-20% discount to your hourly project rate. If you charge $250/hour on projects, retainer hours go for $200-210. The discount is the price the client pays for, well, the discount, and the price you pay for the predictability.

The weakness of this model is that clients fixate on the hour count. They will ask, every month, why a feature took 22 hours instead of 14. You will spend leadership time justifying line items. This is the cost of selling hours.

Capacity-based retainers: selling outcomes without selling outcomes

A capacity-based retainer sells reserved developer headcount. "You get 1.5 developers for the month, $22,000." No hour counting. The client gets a delivery cadence and a backlog management process; you get freedom from time-sheet litigation.

This is the structure most agencies should grow into. It changes the conversation from "how much did that ticket cost" to "what did we ship this month." Sprint retros and burndown charts replace timesheet reviews. Margins also tend higher because you stop billing for context-switching overhead and start billing for committed availability.

The pricing is roughly: (developer weekly cost to you) × (4.3 weeks/month) × (your markup, 1.7 to 2.5x). A mid-level developer costing your agency $1,500/week fully loaded prices at $11,000 to $16,000/month at 1.7x to 2.5x markup. Round to a clean number ($12,500 or $15,000) and that is your single-developer capacity tier.

The risk is real, though. If a client books 2 developers and uses 0.4, you still owe them 2 developers' worth of attention. If they book 1 developer and try to extract 1.5 developers' worth of work, you have an awkward conversation. The fix is a written scope-of-engagement doc that defines what "1 developer" covers: feature work, code review, deploys, support tickets up to a threshold. Anything past the threshold is overage or a separate scope.

Outcome-based retainers: the option you should probably skip

Outcome-based pricing ties the fee to a deliverable or KPI. "$15,000/month if MRR grows by 8%." "$20,000/month for the first 5 features shipped, then $4,000 per additional feature." These read like a sales win on paper and like a margin disaster in practice.

The problem is that you control 30% of the variables in an outcome. The client controls product decisions, marketing spend, hiring, support quality, pricing changes, and whether they actually launch the work you ship. You ate the engineering cost regardless of whether they pulled the lever.

A small set of agencies make outcome-based pricing work, mostly in narrow verticals (Shopify performance, SEO-driven landing-page builds, ad-platform integrations) where the agency owns the full optimization loop and the client just signs off. If you are not in that bucket, sell hours or capacity and let the client absorb the outcome risk. If you are interested in productizing your offer, the dev agency niche positioning playbook goes deeper on which verticals are workable.

The $5,000 floor problem

Most agency owners want to offer a "starter retainer" at $2,500 or $3,000 per month. They lose money on every one of them. The math is hard to argue with.

A $3,000/month retainer at a 50% gross margin nets $1,500 to the agency. Out of that $1,500, you cover account management, weekly status calls, retro prep, ticket triage, and the inevitable scope conversations. Account management alone usually eats 3-5 hours per month, which at any reasonable internal cost burns $600 to $1,000 of that margin before a developer touches anything.

The realistic floor for a useful retainer in 2026 is $5,000/month, and even that requires a tight operating model. Below $5,000 you are losing money in coordination overhead. The agencies that sell sub-$5,000 retainers usually do it as a loss-leader to upsell into a larger engagement, which works if your sales motion can actually convert the upsell. If it cannot, you are funding the client's overhead from your own pocket.

A practical pricing ladder for 2026:

Tier	Capacity	Monthly fee	Use case
Starter	25 hours, no dev allocation	$5,000	Maintenance, small fixes, async only
Growth	0.5 dev, 60 hours, 24h response	$9,500	Active product, weekly cadence
Standard	1 dev, sprint cadence	$16,000	Single-product team replacement
Scale	2 devs + part-time tech lead	$34,000	Multi-feature roadmap
Enterprise	3-5 devs + dedicated PM	$55,000+	Department-level outsource

Notice the Starter tier excludes a dev allocation. That is deliberate. At $5,000 you are selling reactive maintenance, not proactive build, and the structure of the tier should signal that to the client.

Retainers vs project work: the margin math

The reason agencies push toward retainers is simple: a project month and a retainer month earn different amounts of money for the same headcount.

A typical fixed-bid project carries 30-40% gross margin once you factor in scope creep, free revisions, and the discount the client extracted in the sales cycle. A retainer with a clean scope-of-engagement doc and an overage clause runs 45-60% gross margin. On a single mid-level developer, that is the difference between $4,000 and $8,000 of contribution per month.

The other operational win is predictability. Three retainer clients at $15,000/month gives you $45,000 of recurring revenue you can plan against. Three project clients at $45,000 each gives you $135,000 in lumpy revenue and three months of zero pipeline once the projects end. The first model lets you make hiring decisions; the second forces you to oversell to fill capacity.

The trade-off: retainers cap your hourly effective rate. A great project, sold well, can earn $350/hour. A retainer caps you at the blended rate you sold (usually $180-220/hour). You give up upside for stability. Most agencies should make that trade for at least 50% of their book of business, since agency scope creep destroys more project-margin than any retainer ever could.

When to suggest a retainer to a project client

The signal is the third change order. If a project client has come back twice with "small additions," they are not asking for a project. They are asking for a development partner and trying to fund it through the wrong financial structure.

The conversation that converts:

"We've shipped three change orders in five weeks. That pattern usually means you have ongoing work, not a finished project. We can keep billing change orders, or we can move you to a retainer that gives you a predictable monthly cost and us a predictable monthly capacity. Want to compare the math?"

Send a one-page proposal with the project-mode cost projected over six months versus the retainer cost over six months. Include the response-time SLA and a clear scope-of-engagement. The conversion rate on this conversation, in our experience, sits around 55-65% if you catch it at the right moment. The right moment is right after a successful change-order delivery, while the goodwill is fresh.

What to do this week

If you run an agency and you don't have a retainer offer, build one. Start with a single tier (capacity-based, one developer, $14,000-16,000/month, clean scope doc). Sell it to your two best project clients as their renewal comes up.

If your retainer tier exists but is under-margin, audit your last three months of retainer hours and find the coordination overhead. Move it into the price or kill the tier.

If you need extra capacity to fulfill a retainer without hiring, agencies running on Cadence often book engineers under their own brand at the agency markup. A mid-level engineer at $1,000/week from Cadence, billed to the client inside a $12,000/month retainer slot, leaves real margin while the work is delivered by a vetted engineer who is AI-native by default (Cursor, Claude Code, and Copilot fluency are vetted on the voice interview before they unlock bookings). The white-label development services playbook covers the operating mechanics; the partner program covers the referral side, which earns 10% recurring on every founder you send Cadence's way.

Common pricing mistakes

Three patterns kill retainer profitability fast:

• Pricing the retainer at "what the client will pay" instead of what your capacity costs. The client will always pay less than your real cost if you ask them to set the price.
• Skipping the overage clause. If your retainer says "1 developer for $15,000" with no overage rate, you have just sold unlimited capacity for a fixed fee. Always include a 1.25x to 1.5x overage rate on hours above the committed floor.
• Bundling unrelated work into one retainer. A client who wants frontend feature work, DevOps response, and design reviews under one $12,000 retainer is buying three different products at one price. Split them or charge separately.

The cleanest agency operating model in 2026 looks like this: 40-60% of revenue from capacity-based retainers with overage clauses, 30-40% from project work with strict change-order discipline, 10-20% from a single Starter tier that exists as a sales surface for upsell. Pricing the retainer correctly is the lever that makes that revenue mix possible.

FAQ

What is a typical dev agency monthly retainer cost?

A useful dev agency monthly retainer in 2026 costs $5,000 at the floor (maintenance only), $9,500 to $16,000 for a half- to full-developer allocation, and $30,000 to $60,000+ for multi-developer team capacity. Below $5,000, coordination overhead usually eats the margin.

Should I price my retainer by hours or by capacity?

Start with hours-based when your delivery process is still maturing; you learn what work actually costs. Move to capacity-based once you can predict throughput, since it carries 5-15% higher margins and removes timesheet litigation. Most mature agencies end up on a hybrid: capacity floor plus 1.25x hourly overage.

How do I convert a project client to a retainer?

The signal is the third change order in a short window. Send a one-page side-by-side comparing six months of projected change-order billing against a retainer at the equivalent capacity. Convert the client right after a successful delivery, while the trust is high.

What margin should a dev agency retainer earn?

A capacity-based retainer with a clean scope-of-engagement doc should earn 45-60% gross margin. Hours-based retainers run 40-55%. Outcome-based pricing has no reliable margin floor and can run negative. If a retainer is under 35% margin, the price is wrong or the scope is too loose.

Can I use contractors to fulfill a retainer?

Yes, and most growing agencies do. Booking engineers from a vetted marketplace (under your own brand, white-label) gives you elastic capacity without payroll exposure. The margin works if the contractor cost is below 50% of the retainer revenue allocated to delivery; on Cadence's $1,000/week mid tier, a $12,000/month retainer slot leaves comfortable margin for account management and overhead.