The Retainer Ladder: How We Turned One-Off Clients Into Monthly Revenue Without Becoming a Support Shop
Most agencies bolt on retainers as glorified bug-fix contracts and burn goodwill within six months. Here's the tiered model we use to convert project clients into monthly revenue that engineers actually want to work on.
Every agency owner eventually discovers the same thing: project revenue is a treadmill, and retainers are the way off it. Then they sign three retainers, get buried in prod is down Slacks at 11pm, and quietly let them expire. The problem isn't retainers — it's that most agencies sell one flavour of retainer to clients who need three different things.
This is the model we've iterated on over the past four years. We call it the retainer ladder. It has three rungs, each with different pricing, different staffing, and different SLAs. Clients can climb or descend as their needs change, and engineers aren't trapped in a support queue.
Why the "generic retainer" fails
The default agency retainer looks like this: "40 hours a month at a 15% discount, use them or lose them." It sounds reasonable in the SOW and falls apart in month two.
Here's what actually happens:
- Month 1: Client uses 8 hours. Feels ripped off.
- Month 2: Client dumps a redesign request on day 3, blows through 60 hours, argues about overage.
- Month 3: A real incident hits. Your engineer is mid-feature on another client. Response time is bad. Trust erodes.
- Month 6: Client cancels, or worse, keeps paying but resents you.
The root cause is that you've bundled three different services — reactive support, planned evolution, and emergency response — into one SKU with one price and one team. Each of those has a completely different cost structure and staffing model. Treating them as interchangeable hours is how you lose money and good engineers simultaneously.
The three rungs
Think of the ladder as three distinct products that happen to share a client relationship.
Rung 1: Care
This is the baseline. It exists so the client's product doesn't rot. No feature work, no design changes. Scope is strictly:
- Dependency and security patching
- Uptime monitoring and alerting
- Backup verification
- One monthly health report
- A capped number of small bug fixes (we use "anything under 2 hours")
Price it as a flat monthly fee, not hours. In our experience, Care runs somewhere between 8–12% of the original build cost per year, billed monthly. The margin is decent because the work is batchable and predictable — one engineer can handle 6–10 Care clients during a dedicated weekly window.
Critically: Care has no SLA on response time for anything that isn't a P1 outage. A bug report filed Tuesday gets looked at during Thursday's Care block. Clients who can't live with that need to climb the ladder.
Rung 2: Evolve
This is for clients actively investing in the product. They have a roadmap, not a backlog of complaints. Evolve retainers buy a committed slice of a cross-functional pod — typically 0.3 to 0.8 FTE of engineering plus proportional design and PM.
The contract specifies:
- A monthly capacity in engineer-days (not hours — hours invite nickel-and-diming)
- A fortnightly planning cadence
- Named team members with named backups
- Rollover rules (we allow 20% to roll one month, then it expires)
Price this at your standard blended rate with a 5–10% retainer discount — not because the work is cheaper, but because predictable capacity lets you staff better. Evolve is where most of your retainer revenue should live.
Rung 3: On-Call
This is the premium tier, and it's the one most agencies get wrong by giving it away free inside Care. On-Call means: we will respond to a P1 within 30 minutes, 24/7, including weekends.
That's a different business. You need rotation, pager duty, runbooks, and engineers who have signed up for it (and get paid extra for it). You cannot staff this out of goodwill.
Price On-Call as a separate line item on top of Care or Evolve. We charge a fixed monthly availability fee plus a time-and-materials rate for actual incident work, with a minimum billing increment of one hour per incident. The availability fee exists to pay the on-call engineer whether they get paged or not.
A sample pricing structure
Here's the kind of structure we'd put in front of a mid-market client post-launch. Numbers are illustrative; your rates will vary.
CARE $1,800 / month flat
- patching, monitoring, <2h fixes
- best-effort response, Thu block
EVOLVE S $12,000 / month ~6 eng-days
EVOLVE M $22,000 / month ~12 eng-days
EVOLVE L $38,000 / month ~22 eng-days
- named pod, fortnightly planning
ON-CALL $2,400 / month availability
+ $240 / incident-hour, 1h minimum
- 30-min P1 response, 24/7
Notice what's missing: there's no "hours bucket" anywhere. Hours are an input, not a product.
The contract language that saves you
Two clauses do most of the heavy lifting.
The scope anchor. Care contracts include an explicit list of what Care is not. Something like:
Care does not include: new features, UI changes beyond text copy, third-party integrations, data migrations, performance work, or any task estimated at more than two hours. Requests of this nature will be quoted separately or handled under an Evolve engagement.
This is the single most important paragraph in the entire ladder. Without it, every Care client will slowly try to turn their contract into an Evolve contract at Care prices.
The climb clause. Clients can upgrade mid-month with no penalty; downgrading requires 30 days notice. This makes it easy to say yes to growth and harder to churn impulsively.
Staffing it without burning people out
The ladder only works if you staff each rung differently.
- Care is handled by a rotating "platform engineer of the week" — usually a mid-level who batches the work into two half-day blocks. One person covers 6–10 clients.
- Evolve is handled by durable pods assigned to specific clients. Continuity matters here; context-switching kills margin.
- On-Call is a volunteer rotation with a pay premium (we pay a weekly stipend plus incident multipliers). Nobody is drafted into On-Call.
The mistake we made early on was using the same engineers for all three. Your best senior would be mid-flow on an Evolve feature when a Care patching task landed, context-switch to fix it, and then get paged at 2am. We lost two engineers to that pattern before we restructured. Now, the only person who crosses rungs in a given week is the tech lead reviewing output.
Selling the ladder to existing clients
The conversion script we use after a project ships looks roughly like this:
- Two weeks before launch, send a one-page "what happens after launch" doc explaining the three rungs.
- Default-recommend Care + the smallest Evolve tier for 90 days. Frame it as a stabilisation period.
- After 90 days, review usage data together. Most clients either drop to Care-only or settle into a steady Evolve tier.
- Only pitch On-Call to clients whose product actually has 24/7 users. For a B2B tool used 9–5 in one timezone, On-Call is overselling.
About 60–70% of our post-launch clients take Care. Roughly a third of those climb to some Evolve tier within six months. On-Call is a small fraction — maybe 10% of retainer clients — but it's high-margin and it tells us which products are mission-critical, which informs how we price future projects for similar clients.
What we'd do if we were starting over
If you're an agency owner reading this with a stack of generic "40 hours/month" retainers, don't try to migrate everyone at once. Pick your next three post-launch clients and sell them the ladder from day one. Write the scope anchor into the Care contract. Pay someone a real stipend to be on-call. Track margin per rung separately in your books — you'll quickly see which tier is actually funding the lights.
And before you redesign your pricing page, redesign your capacity model. A ladder you can't staff is just a prettier version of the same treadmill. If you want a second pair of eyes on how your post-launch offering is structured, that's the kind of thing our product strategy work is built around.
Want a team like ours?
72Technologies builds production software for the kind of teams who actually read this blog.
Start a projectKeep reading
Killing the Discovery Phase: Why We Replaced It With a Paid Architecture Sprint
Discovery phases rot. They produce PDFs nobody reads and estimates nobody trusts. Here's the paid architecture sprint we run instead, and why clients actually pay for it twice as often.
The Statement of Work Is a Product: How We Rewrote Ours After Losing Three Fixed Bids in a Row
An SOW isn't paperwork. It's the first thing your client reads in anger when a project goes sideways. Here's how we rebuilt ours to actually protect both sides.
The Equity Deal That Almost Sank Us: A Framework for Agencies Taking Stock Instead of Cash
Taking equity from a client sounds like free lottery tickets. It isn't. Here's the framework we use to decide when stock beats a wire transfer — and when it's just a discount with extra paperwork.
