Same standard of craft, different centre of gravity. This page is the long version: what you own, what we own, how a team is composed, how long it takes to ramp, what it costs, and the point at which each model stops being the right one. If you would rather skim, the decision table below is enough.
Most engagements are mis-scoped at the beginning, not mismanaged later. Find the row that describes where you are; the last column is the honest cost of that choice.
| Where you are | The model | Why it fits | What it costs you |
|---|---|---|---|
| We know what to build, we just need more hands | Team Extension | Your process is already working; adding capacity is the cheapest intervention | You keep all management overhead |
| We have a roadmap but nobody to run another team | Dedicated Squad | You get one accountable unit instead of five individuals to coordinate | You give up day-to-day control of how work is sequenced |
| We have a business problem and no engineering org | Product Partnership | Discovery, architecture and delivery held by one accountable party | You trade control for accountability, and pay for the definition work |
| Headcount is frozen, the roadmap is not | Team Extension | Contracted capacity sits outside headcount and scales back cleanly | Budget moves from people cost to project cost |
| A whole new surface needs building in parallel | Dedicated Squad | A ring-fenced team that will not be pulled onto core firefighting | Six-month horizon before the squad pays back its ramp |
| A legacy system must be replatformed without breaking | Product Partnership | Migration risk is held by the party doing the migration | Phase gates mean slower starts and firmer plans |
Your team, several engineers larger, without a hiring cycle.
We place vetted senior engineers directly inside your existing squads. They attend your stand-ups, write against your definition of done, submit pull requests into your repositories, and report to your engineering manager. Nothing about your process changes — only your capacity does. This is the model to pick when you already know what to build and how you want it built, and the constraint is simply how many capable hands you have.
Brief reviewed, role profiles agreed, search opened against our bench and network.
Shortlist delivered with CVs, code samples where available, and our interview notes.
Your interviews. We schedule, prepare and debrief; you decide.
Contracting, NDAs, background and reference checks, equipment and access.
Onboarding into your codebase — first pull request typically inside the first fortnight.
When you find yourself directing five or more of our engineers and your own manager becomes the bottleneck, the coordination cost has moved onto your side of the table. That is the point to move to a dedicated squad and hand the delivery management back to us.
A complete team, run by us, pointed at your product.
We assemble a cross-functional squad — engineers, QA, a delivery lead, design and DevOps as needed — and run it as a unit against your roadmap. You keep product ownership and set direction; we own team performance, delivery cadence, and everything that keeps a team functioning. It is the closest thing to having a second engineering office without opening one.
Discovery: goals, constraints, existing systems, definition of done, risks.
Squad shape proposed and agreed, named people presented for your review.
Contracting, access, environments, tooling and security onboarding.
Sprint zero — backlog shaped, architecture agreed, CI green, first increment planned.
Regular delivery cadence with weekly demos and written reporting.
When the squad is effectively defining the product as well as building it — deciding scope, trade-offs and sequencing — you are already in a partnership. Making that formal gives you commercial protection and gives us the mandate to say no to the wrong work.
You describe the outcome. We own getting there.
We take a product from discovery through architecture, build, launch and the first months of operation. You bring the business problem, the users and the decisions only an owner can make; we bring everything else, including the accountability for whether the thing works. This is the heaviest model we offer and the one with the least ambiguity about who is responsible.
Discovery — two to four weeks. Problem, users, constraints, scope, and a costed plan.
Foundations — architecture, environments, CI/CD, security model, design system.
Build — increments delivered on a fixed cadence with demos and phase gates.
Launch — hardening, load and security testing, runbooks, go-live.
Operate or hand over — stabilisation, then transfer to your team or ongoing support.
Partnership ends well when your own team can hold the product. We plan that exit from the first phase — documentation, runbooks and, if you want it, help hiring the people who take over.
These are not model-specific extras. They are the baseline we hold ourselves to, and the reason a roster can grow without the relationship degrading.
Six on our side, then your own interview loop as the final gate.
Whatever the roster size, itemised by role for your finance team.
A wrong placement is ours to fix, including the replacement's ramp.
One person accountable for the engagement, reachable in your working hours, who is not billing you as an engineer.
Every engineer passes a technical interview, a live problem-solving session, a code review exercise, operator references and a communication screen before you ever meet them.
Access checklist, environment setup guide, glossary of your domain, and a 30-day ramp plan written per person.
Work happens in your version control under your standards. There is no black box you receive at the end.
Architecture decisions, runbooks and setup guides are written as work happens, not reconstructed at handover.
Code review on every change, automated tests in CI, and an agreed definition of done that we hold ourselves to.
If a placement is not working, tell us. We replace at our cost and carry the ramp of the replacement.
Handover documentation, knowledge transfer sessions and an offboarding checklist — written before you need them.
Whatever the roster size, your finance team receives a single monthly invoice with a per-role breakdown.
We do not publish a single day rate, because a single number would be wrong for almost everyone. Here is every input that moves the figure, so nothing in a proposal reads as arbitrary.
Mid, senior, staff and principal are priced differently because they solve differently sized problems. Most rosters are senior-weighted; we will tell you when a mid-level engineer is the honest fit rather than upselling.
Platform, ML, security and specialised mobile skills price above general application engineering because the market prices them that way.
A twelve-month commitment prices below a rolling three-month one. Longer commitments let us hold people for you rather than re-sourcing.
A squad price includes the delivery lead, QA gates and reporting. Comparing a squad rate to a single contractor rate is comparing different things.
Full overlap with a narrow time zone window restricts the pool and prices accordingly. Broad overlap requirements price lower.
Sourcing, interviews, failed placements, replacement ramp, equipment, contracting, admin and the delivery contact on extension engagements.
A brief produces a written proposal with a per-role breakdown, the assumptions behind it, and the notice and scaling terms attached. If our recommendation is a smaller engagement than you asked for, the proposal will say so and explain why.
Answered at the length the question deserves, including the ones that are awkward for us.
A shortlist typically lands within a week of a complete brief. From your acceptance, contracting and onboarding usually take a further one to two weeks, so a realistic first-commit date is three to four weeks from the brief. Specialised roles — principal-level ML, niche embedded work, hard compliance constraints — take longer and we will say so up front rather than promising a date we would miss.
Tell your delivery contact as early as you feel it. We investigate, and if the fit is genuinely wrong we replace the person at our cost and carry the ramp time of the replacement. We would rather absorb that than defend a placement nobody is happy with.
Team extension: three-month initial term, then 30 days' notice either way. Dedicated squads: six-month initial term, then 60 days. Partnerships are phase-based, with an exit defined at each gate. Notice runs both directions — the same terms protect you and us.
Yes, and it is the point of the model. Roll people off within the notice cycle without severance exposure, employment claims or the political cost of a redundancy process. We handle the person's next placement.
We staff for overlap with your working day rather than for a particular country. Tell us the hours you need covered and we build the roster around them; where you need follow-the-sun coverage we split the roster across windows.
You do. IP assignment is written into every contract and flows through to each individual engineer's agreement. Code lives in your repositories under your accounts from day one, so ownership is a fact of the setup rather than a promise at the end.
Mutual NDAs before any detail is shared, individual NDAs for every person on the engagement, access on a least-privilege basis through your identity provider, and device policies matched to your requirements. Where you have a security questionnaire or vendor review process, we complete it.
The people on your engagement are engaged by us and vetted by us. We do not resell another agency's bench without telling you, and you always know who is on the roster because you meet them before they start.
Often, yes. There is a conversion path with a fee that steps down the longer the person has been with you. We would rather help a good placement become permanent than lose the relationship defending it.
Yours, in extension engagements — your tracker, your repos, your rituals, your definition of done. In squads and partnerships we bring a working setup by default, and adapt to yours wherever you have an opinion.
Extensions report through your own process; we add a monthly performance check-in. Squads produce a written weekly report and a live demo, plus a monthly business review. Partnerships add phase-gate documents with costs and decisions.
A brief covering the problem, the stack, the shape of the team and the constraints; a named decision-maker; and access to whoever can answer domain questions. Everything else is our side of the table.
Six short steps in the brief. You get a written read-back, a recommended model with reasoning, an indicative cost range and a realistic start date — within one business day.