If you are hiring for the role, keep hiring: the core of your product needs people who stay. While the seat is open, hand one bounded piece of the work, with a clear finish line, to a project team that delivers it and hands it back. The work starts now, and your new hire inherits working, documented code instead of a backlog.
This is not an argument against hiring. The core of your product belongs with people who will still be there in two years. The question is narrower: what happens to the work while the seat is empty, and how do you hand part of it out without leaving a mess for your new hire?
Why waiting for the hire is costly
Hiring an engineer takes months, and a new engineer then needs time to learn your codebase. The work waits through both.
Ashby's 2026 Talent Trends data, drawn from about 247,000 jobs on its recruiting platform, puts the median time from opening a technical role to making the first hire at 76 days, against 56 days for business roles (Ashby, Recruiter Productivity report). That clock stops when the hire is made, not when the person starts.
Then comes ramp-up. DX found that new engineers at six multinational enterprises took 49 days to reach their tenth pull request, a common marker of ramp-up, if they used AI coding tools daily, and 91 days if they did not (DX). Your numbers will differ, but the shape holds: months to hire, then more time to ramp up.
Meanwhile your engineers spend hours interviewing, the work keeps slipping, and the new hire's first months go to the backlog instead of the product.
What to hand out and what to keep in house
Hand out work that has a defined other side and a finish line someone outside your company can check. Keep the work that needs your product judgement every day.
| Work | Hand it to a project team? | Why |
|---|---|---|
| An integration with a defined other side (a payment provider, CRM or a customer's API) | Good fit | The other system's API sets the scope |
| A framework or runtime upgrade, such as Django or Python | Good fit | Done is the supported version in production, tests passing |
| An internal tool or admin panel | Good fit | Your own staff are the users, so requirements can be checked with them |
| A first AI workflow pilot with an evaluation set | Good fit | The evaluation set defines success before the build starts |
| A data pipeline with validation | Good fit | Inputs, outputs and the checks between them can all be written down |
| A production-readiness pass before real users arrive | Good fit | The review areas are known: authentication, secrets, data access, tests, monitoring |
| The core product's direction | Keep in house | It needs someone who lives with the product and its customers |
| Work that needs daily product decisions | Keep in house | A fixed scope breaks if the answer changes every morning |
| Anything with no clear finish line | Keep in house until it has one | There is nothing to scope, test or hand back |
A simple test: can you describe "done" in one paragraph that an outsider could check? If yes, the work is a candidate. The best first piece is often one your new hire would otherwise inherit as a chore, such as the overdue upgrade.
How to write the brief so a project team can quote a fixed scope
A one-page brief is enough if it answers five questions. Without those answers, any fixed quote is a guess.
- The outcome, in business terms. "Orders placed in the app appear in the accounting system, and failed syncs are retried and reported" is a brief; "integrate with the accounting system" is a topic.
- The systems it touches: repositories, databases, third-party services and environments, plus anything it must not change.
- The access needed: which accounts, who on your side grants them, and how secrets are shared (through your password manager, never by email).
- What "done" means: tests passing in your CI, documentation in the repository, where the work is deployed, and a recorded handover session. This becomes the acceptance check at the end.
- Who answers questions on your side: one named person who knows the systems and can sign the work off.
Expect a good team to come back with questions and a written scope that lists what is out of scope. A fixed quote with no questions means the scope exists only in their heads.
Your options while the role is open
There are four realistic options. They differ most in who owns the outcome and what you hold at the end.
| Option | Who owns the outcome | How you pay | What you get at the end | Main risk |
|---|---|---|---|---|
| Wait for the hire | You, through the new hire once they start | Salary, from their start date | The work, begun later by someone still learning the codebase | The piece keeps slipping, and the new hire starts on a backlog |
| Contractor or freelancer | Usually you; they own their tasks | Hourly or daily, sometimes a fixed fee | Whatever was finished, documented as far as they chose | Knowledge sits with one person, and quality depends on how closely you manage it |
| Staff augmentation (an outside engineer working inside your team by the hour) | You: you direct the work day to day | Hourly, while the engineer is in place | Extra capacity while the engineer is there | You carry the management load, and what they learned leaves with them |
| Fixed project with handover | The project team, against the agreed scope | Fixed scope, agreed before work starts | Working code in your repository, with tests, docs and a recorded handover | A vague brief turns into change requests |
Each option has its place. Waiting is right when the piece needs the person you are hiring, and a contractor suits a small task someone on your team can direct. Staff augmentation is used by teams with the management time to direct extra hands inside their own process. MicroPyramid does not work that way: we do not place engineers inside client teams. We take on a defined piece of work, finish it and hand it back.
What the new hire should receive
The handover is the point of the whole exercise. Your new hire should be able to run, change and deploy the work without calling anyone.
Agree the contents before work starts. The new hire, or whoever owns the code until they join, should receive:
- The repository in your own account (your GitHub, GitLab or Bitbucket organisation) from the first commit, so nothing needs transferring and the history is already yours.
- Tests that run in your CI on the important paths, so the new hire can change the code safely.
- A runbook: set up, run the tests, deploy, roll back, and handle the common failures.
- Architecture notes: what was built, how it connects to your system, and why the main decisions were made.
- A recorded walkthrough of the code and the deploy, useful even if the hire joins months later.
- Open issues in your tracker: known limits, what was left out of scope, and suggested next steps.
Working in your own accounts from day one also means nothing sits in someone else's name if anyone leaves. The test of the handover is the new hire's first task: a small change, deployed using only the runbook. If that fails, fixing it is the project team's job, not the new hire's.
For the full list of what to collect whenever code changes hands, see our software handover checklist. If someone has already left, start with what to secure in the first 48 hours.
When not to do this
If the role exists because you need someone in your product discussions for years, a project team is not a substitute. Hire, and use outside help only for the bounded pieces.
Signs that the work belongs with the person you are hiring:
- The role is your first engineer or technical lead, valued for judgement about the product over time.
- The work is the core product roadmap, and its direction changes as you learn from customers.
- You cannot name a finish line, even after trying.
In those cases, keep the role open until you find the right person; a project team can still take an upgrade or integration with a clear end. And if nobody on your side can answer questions during a project, wait, because a fixed scope without an owner drifts.
How we work at MicroPyramid
We are a lean team that takes on defined projects, finishes them and hands them back. Ongoing maintenance is optional and runs month to month.
Most of our projects start with a fixed-scope first step:
- Agent Pilot Sprint for a first AI workflow: one workflow running on your own data, with an evaluation set and a rollout plan.
- Upgrade Assessment for Django, Python and cloud upgrades: a dependency and end-of-life audit, and an upgrade path with the risks called out.
- Production-Readiness Audit for an app heading to real users: a security, code and test review, and a fix list in priority order.
For an app another team built, we start with a Takeover Assessment instead.
Then we deliver the project in your repository and hand it back with tests, documentation, a runbook and a recorded walkthrough. If it helps, we maintain and develop it on a monthly retainer that runs month to month with 30 days' notice, and it simply ends when your team takes over. See products we have built and run in our portfolio.
If you have an open role and a piece of work that should not wait for it, tell us about it: the role, the piece and what done looks like. We will tell you plainly whether it suits a fixed project or is better left for your hire.
Frequently Asked Questions
Short answers to what buyers ask when an open role meets an outside team.
Should I hire or outsource this project?
Often both. Hire for the work that needs someone in your product decisions for years, and hand out pieces with a clear finish line. If an outsider could check what "done" means, the piece suits a fixed project.
What kind of work is best to hand to an outside team?
Work with a defined other side and a checkable finish line: integrations, upgrades, internal tools, a first AI pilot with an evaluation set, a validated data pipeline or a production-readiness pass. Keep the product's direction and daily product decisions in house.
Who owns the code?
You should, from the first day. The work happens in a repository in your own account, so nothing needs transferring at the end. Check that the contract says the code belongs to your company.
How does the new hire take over the work?
They start from a repository they already have, with tests, a runbook, architecture notes, a recorded walkthrough and open issues. If they join before the project ends, they sit in on the handover session; if later, the recording and runbook do that job.
What if the scope changes during the project?
Small clarifications are part of any project. A real change is written down, with its effect on timeline and cost agreed before work on it starts. If the piece changes every week, it probably belongs with your in-house team.
What drives the cost of a fixed-scope project?
The number of systems the work touches, how well they are documented, the state of the existing code and tests, the data preparation needed, and what "done" includes. A clear brief and a responsive owner on your side keep the scope tight.
Can you provide an engineer to work inside our team until we hire?
No. We do not place engineers inside client teams. We take on a defined piece of work as a fixed project, hand it back with tests and documentation, and can then maintain it monthly if that helps.