Fixed price per project
One agreed price for a defined scope, agreed before work starts. You know the total cost on day one and it does not move unless the scope does.
$15,000–$60,000 per project
Best for
Well-understood work with a clear finish line — a migration, a rebuild, a defined integration, a compliance deadline. Also the right choice when the budget has to be approved up front and cannot be revisited.
How billing works
- Scope, deliverables and acceptance criteria agreed in writing before kickoff
- Billed against milestones, not hours — typically an initial payment then staged on delivery
- Changes to scope are quoted separately before they are picked up
Where it breaks down
Fixed price requires fixed scope, and that is where it bites. Every change becomes a change request with its own price and timeline, which slows you down mid-project. If you expect requirements to shift as you learn, this model turns discovery into paperwork — a retainer will cost less and move faster.
Fixed price per feature
The same certainty as a fixed-price project, but scoped one feature at a time. You buy increments and can stop, reprioritise or change direction between them.
Pricing on request
Best for
Live products with a roadmap that keeps moving. You get budget predictability per item without committing to a twelve-month scope you will have rewritten by month three.
How billing works
- Each feature scoped, priced and approved before work begins
- Billed on delivery of each feature, not on a monthly cycle
- No commitment to a minimum number of features
Where it breaks down
Estimating each feature has overhead, so very small items carry disproportionate scoping cost — batching them helps. It also optimises for what is easy to scope, which can quietly starve refactoring and platform work that has no user-facing deliverable. Budget for that separately.
Developer retainer
One or more of our engineers allocated to your team for an agreed number of days per month. They work inside your process, your standups and your repositories.
$7,000–$11,000 per month
Best for
Ongoing delivery where priorities change week to week, and for extending a team that already has technical direction but not enough hands. The lowest-overhead model once work is continuous — no scoping cycle between tasks.
How billing works
- Billed monthly per allocated engineer, based on agreed days per month
- Rolling monthly term with an agreed notice period — no long lock-in
- Unused days do not roll over; allocation can be adjusted between months
Where it breaks down
You are buying capacity, not a guaranteed outcome, so the value depends on your ability to direct the work. Without a clear owner setting priorities, retainers drift. If you need someone to decide what gets built rather than build it, a fractional CTO engagement is the better fit.
Fractional CTO
Senior technical leadership on a part-time basis — architecture decisions, technology choices, hiring, vendor selection and engineering process, without a full-time executive salary.
$4,000–$8,000 per month
Best for
Funded startups without a technical founder, and established companies whose engineering has outgrown its structure. Also useful as an independent second opinion before a large platform commitment or a build-versus-buy decision.
How billing works
- Monthly retainer based on agreed days per month — typically two to four days
- Typically a minimum three-month term, since the first month is mostly context-building
- Can be combined with a developer retainer or fixed-price delivery
Where it breaks down
This is advisory and decision-making capacity, not delivery capacity — it does not ship code, and pairing it with a delivery model is usually necessary. It also depends on real authority: a fractional CTO with no mandate to change anything produces documents nobody acts on.
If the scope is genuinely fixed and the deadline is external, take the fixed-price project. If you have a live product and a moving roadmap, fixed price per feature gives you predictability without freezing your plans.
If work is continuous and you already have someone setting technical direction, a developer retainer is the cheapest and fastest option — there is no scoping overhead between tasks. If the gap is direction rather than capacity, start with a fractional CTO engagement and add delivery afterwards.
Most engagements that run for more than a few months end up combining two of these. That is normal, and we would rather restructure the arrangement than have you keep paying for a model that has stopped fitting.