You raised a round. The deck promised a product that doesn't exist yet, and the board wants to see it ship. You have enough budget for exactly one move: hire a senior engineer and start building a team, or sign an external firm and start building the product. Not both. The numbers don't stretch to both, and pretending they do is how seed rounds evaporate.
So you're stuck at the fork. The investors who've seen this before tell you to "build your own team early — software companies are engineering companies." The investors who've been burned tell you "don't hire until you know what you're building." Both are right, which is useless, because they're answering different questions and you only get to make one call.
Here's the part that makes this expensive: the wrong choice doesn't fail loudly. It fails slowly, over a year, and by the time you can see it, you've spent the runway that would have let you correct it.
What the wrong call actually costs
Run the two failure modes forward.
You hire first. A senior engineer in a US market costs you $180k to $220k all-in, plus three to five months to find and close the right one — recruiting is a part-time job you now do instead of selling. Say you land them in month four. They're excellent, but they're one person, and one person building a full product is a sequential machine: backend, then frontend, then infrastructure, then the integration that surprises everyone. A solo senior ships a real product in nine to fourteen months. Add the four months of recruiting and you're at a year-plus before you have something to put in front of customers. You spent $200k to learn what the market thinks about a product you finally shipped fourteen months after the round closed.
You outsource first — to the wrong firm. A body shop quotes you a low rate, staffs your project with whoever's on the bench, and hands you a codebase that demos beautifully and falls apart the first time you try to change it. Now you're hiring that first engineer anyway, except their first six months go to untangling someone else's mess instead of building forward. You paid twice: once for the build, once for the rescue.
Both paths burn roughly the same year. The difference is what you have at the end of it — a thin team and a late product, or a shipped product and a codebase you may or may not be able to live in. The decision isn't "team versus vendor." It's which sequence gets you to a defensible product with the least wasted runway.
What a first engineer gives you, and what it costs
A great first engineer is a compounding asset. They set the technical culture, they're there at 2am when production breaks, and every decision they make is one they'll have to live with — which means they make them carefully. Equity aligns them with the outcome in a way no contract aligns a vendor. If you're building something where the software is the company — a deep technical product, a platform others will build on — you want this person early, and you want them to own it.
The costs are the parts founders underweight.
Recruiting is slow and you're bad at it. You don't yet have an engineering brand, a senior person to run the technical interview, or the network to source candidates. The good ones have options and your pitch is "join a pre-product startup as employee number one." Three to five months is optimistic.
Ramp is real. Even a perfect hire spends their first month learning the domain, the customers, the constraints. You're paying full salary for partial output while they build context that a founder already has.
One person is a single point of failure. They get sick, they take vacation, they get a better offer in month eight. Until you have two engineers, your entire technical capability can walk out the door, and everything they knew that wasn't written down walks with them.
A first engineer is the right first move when you already know what you're building, the product is technically deep, and the software is the moat. It's the wrong first move when the spec is still moving and you need to ship something to find out if anyone wants it.
When outsource-then-hire is the right sequence
For most funded founders at the pre-product stage, the right sequence is: a senior external team builds the first real version, then you hire an engineer to own and extend it. Here's why the order matters.
Speed of standing up. A real firm has a team ready on day one — backend, frontend, infrastructure, someone who's seen the integration surprises before. They build in parallel what a solo hire builds in sequence. The same product that takes a solo senior twelve months takes a focused team four to six. You get to market while your runway is still mostly intact, and that's what funds the next decision.
You de-risk the hire. Once a product exists and customers are using it, you know what kind of engineer you actually need — and you're recruiting into a real company with a shipped product instead of a slide deck. The pitch goes from "trust me" to "here's what's live, come own it." Good engineers say yes to that.
The catch — and it's the whole game — is that this only works if the external team builds something a future employee can inherit. That means a documented architecture, a codebase organized for handoff, no proprietary lock-in, and a deliberate transition where your new hire is brought up to speed by the people who built it. A firm that builds for handoff is buying you a sequence. A body shop that builds for billable hours is selling you the rescue project I described earlier.
The question to ask any firm: "What does the handoff to our first internal engineer look like, and is it in the contract?" If they don't have a crisp answer, they're not building for you to own it. They're building for you to stay dependent.
The failure modes, named
Hiring too early into a moving spec. You hire a senior engineer before you know what you're building. They build the wrong thing well, you pivot, and now you're throwing away expensive, carefully-built code — and possibly the engineer, who signed up to build the first thing.
Outsourcing to the cheapest bid. The rate that looked great produces a codebase nobody can maintain. The savings were a loan against your next two quarters.
Outsourcing forever. You ship, it works, and you never build internal capability because the vendor relationship is comfortable. Two years in, you have a product you don't understand, can't independently change, and a vendor who knows it. That's not a partnership. That's a hostage situation with monthly invoices.
Hiring one and stopping. You make the first hire and treat the single-point-of-failure risk as solved. It isn't solved until there are two. One engineer is a liability wearing the costume of a team.
What fixed looks like
Fixed is a sequence, not a coin flip. You decide based on two things: how settled the spec is, and how deep the technical moat is.
Settled spec, deep moat, software-is-the-company: hire the senior engineer first, build deliberately, accept the slower timeline because the ownership compounds.
Moving spec, need to ship to learn, runway that won't survive a fourteen-month solo build: a senior external team builds the first version for handoff in four to six months, then you hire an engineer into a real company with a real product and a clean transition. The codebase was built to be inherited, the architecture is documented, and your new hire is productive in weeks because the people who built it walked them through it.
Either way, you end up with internal capability. The question was never whether to build a team — it's whether you build the product first or the team first, and which order wastes less of the year you can't get back.
This is for you if
You're a funded founder with budget for one move and a board that wants to see product. You need someone to tell you, with your actual spec and runway in front of them, whether to hire first or build first — and if you build first, to do it in a way your future team can own.
A scoped build-for-handoff engagement starts at $50k+ for a first version designed to be inherited — documented architecture, clean codebase, a transition plan in the contract. $100k+ for a full product with a deliberate handoff to your first internal hire, including the onboarding. If you mainly need a decision — hire-first or build-first, with the reasoning and a hiring profile — that's a $25k+ advisory engagement.
This is not for you if the software is genuinely your company's core IP and you already know exactly what you're building — hire the senior engineer, own it from line one, and don't outsource your moat. It's not for you if you're looking for the cheapest possible build, because the cheap build is the one you pay for twice. And it's not for you if you want to outsource forever and never build internal capability. The right external team builds you something to grow into, then hands you the keys. If a firm isn't planning its own exit, find one that is.