Request pricing

We scope every engagement before we price it, so the number you get is the number you pay. Tell us what you are building and an engineer sends back a written scope and a fixed price.

  • A written scope: what is in, what is deliberately out, and the timeline
  • A fixed price for the work, not an hourly rate
  • The engagement model we think fits, and why the other two do not
  • A named engineer you will actually be working with
  • Mutual NDA before scope, if you want one

An engineer reads it and replies within 24 hours. No sales sequence, and we say so if we are not the right fit.

First Sprint

One scoped release, so both sides can judge the fit

4-6 weeks

Fixed scope · pricing on request

  • One release: scoped, priced and shipped in full
  • Fixed price agreed before we write code
  • 4-6 weeks from kickoff to live
  • Design, build, QA and deployment from one team
  • A demo you can click every week
  • Repo, hosting and domains in your accounts
  • 30 days of support after launch
Most Popular

Product Partnership

For teams whose roadmap runs past the next release

Monthly

Ongoing roadmap · pricing on request

  • A standing team, not a maintenance drip or a queue of one-off projects
  • The same engineers every sprint, not whoever is free
  • Two-week sprints, each ending in a demo
  • Roadmap, design, build, QA and release
  • Ongoing work continues month to month after the build
  • Priced against one mid-level hire, with nobody on the bench
  • You message the engineers, not an account manager
  • Month-to-month billing, never a 12-month contract

Embedded Team

For CTOs and agencies who need senior capacity inside their own process

Dedicated

Scoped to your team · pricing on request

  • Senior engineers own every commit that reaches your repo, and review anything they did not write
  • Your repo, your board, your standups
  • Code review and CI to the standards you already run
  • White-label: your PM stays the client contact
  • Mutual NDA before scope, IP assigned on delivery
  • At least four hours of overlap with your working day
  • Architecture and security review before we scale up
  • Agreed response times for production issues, written into the SOW

Not sure which one you need?

30 minutes with an engineer, not a salesperson. We'll scope what you're building, tell you which model fits, and say so if none of them do. You'll leave with a plan and a number, even if we're not the right fit.

See our work

The questions worth asking before you sign

If you have one clear release in mind, start with a First Sprint. If your roadmap runs past that release, a Product Partnership is cheaper and faster than restarting a project every quarter. If you already have engineers and just need more senior capacity inside your process, that is an Embedded Team. We will tell you on the call which one fits, including when the honest answer is none of them.

You do, from the first commit. Work happens in your GitHub organisation, hosting and domains sit in your accounts, and IP is assigned to you in writing at delivery. We keep no rights to reuse what we build for you and there is no licence to buy back.

A sprint is fixed scope, so it ends when the work ships. Ongoing work is billed monthly, not on a 12-month contract. If you leave, you already hold the repo, the deployment setup and the documentation, because they were yours throughout. We do a handover call with whoever picks it up.

That is the right comparison, and the one we would make. For roughly what a mid-level developer costs you, you get engineering, design, QA and releases from a team that has shipped 65+ products. No recruitment, no notice periods, and nobody sitting on the bench when the roadmap goes quiet.

We scope in the first week and you have something to click in the second. On an existing codebase the first sprint is deliberately small, a real ticket reviewed by your own team, so you can judge the code before you commit to more of it.

Every change is reviewed before it merges and runs through CI. The strongest evidence we can offer is that we run our own software in production: five products of our own, three of them serving paying business customers, and we are the ones woken up when they break. We write code we have to maintain ourselves.

You get a shared channel with the engineers doing the work, not an account manager relaying messages. We fix an overlap window of at least four hours with your working day and write it into the SOW: standups and demos happen inside it, deep work carries on outside it. You see commits as they land and a demo every sprint.

No, and we sign that before any introduction. We work under your brand, your PM stays the client contact, and we stay out of the client relationship unless you invite us into it. Mutual NDA first, as standard.

Typically 30% upfront, 40% at midpoint, and 30% on delivery. For ongoing work, we bill monthly in advance. We accept wire transfers and major credit cards.

Billing by the hour, rescue jobs where the plan that already failed is the plan we are handed, and budgets so tight the only way to deliver is to put juniors on them. We say no to work we cannot ship well. It is cheaper for both of us to find that out on a 30-minute call than three months in.

Next step

Tell us what you're building and we'll tell you what it takes

A scope, a timeline and a number, in writing, before anyone signs anything. 30 minutes. No pitch. You keep the plan either way.

See our work