The contract that looked smart in the board deck
Picture the moment. You just closed your Series B. The board wants the roadmap to double, the runway to stretch, and the burn multiple to behave. Your VP Eng pulls up two numbers. A senior engineer in the US runs roughly $234k all-in once you load benefits, equipment, and recruiting. An offshore agency quotes a blended $75 an hour. The spreadsheet practically signs itself. You take the agency, route four roadmap epics to them, and tell the board you bought velocity at a discount.
Eighteen months later you are not faster. You are negotiating with a vendor who is the only entity on earth that understands how your billing service actually works, while your own engineers refuse to touch it. That is the specific failure mode of a Series B build decision: it does not blow up in the quarter you make it. It blows up the quarter before your next raise, when the codebase you rented is suddenly the asset you are trying to sell.
Why "cheaper per hour" inverts
The hourly comparison is the wrong frame because it prices labor, not ownership. Benchmark data from BCG and the engineering-economics literature lands on an uncomfortable number: outsourcing can shave up to 40% off initial cost, but the total cost of ownership for poorly governed external code runs about 1.5x higher over 24 months once you count remediation. The discount is real on day one and a mirage by month 18. Three forces drive the inversion, and at Series B each one is amplified by the fact that you are scaling, not prototyping:
- The rework tax compounds on a bigger base. Sonar's work on the cost of technical debt pegs developer time lost to debt at roughly a third of capacity in a typical team. In an externally built service with no internal owner, that share climbs past half, because the people billing for the fix are the same people who get paid by the hour. The incentive is to charge for outcomes you should already own.
- Clarification latency taxes a roadmap, not a feature. A 12-hour time-zone gap does not mean "they work while you sleep." It means one ambiguous ticket costs a full day, and at Series B your tickets are ambiguous on purpose, because you are still finding product-market fit in the next segment. Multiply a one-day clarification delay across a two-week sprint and you lose roughly a third of the velocity you were paying a premium to gain.
- An agency builds the ticket; you needed the product. Pre-Series-B that gap is survivable. At Series B, where you are extending into adjacent use cases the original spec never imagined, "built exactly what was asked" produces a product that passes QA and misses the market.
The two questions that sort every epic
The mistake is treating "build or outsource" as one decision. It is a per-module decision, and Series B founders get it backwards in a predictable way: they outsource the thing that makes them special and hoard internal payroll on the thing that does not. They hand the matching algorithm or the pricing engine to a vendor because it is hard, then put a $200k engineer in charge of babysitting a Stripe integration because it is familiar.
Sort each piece of your roadmap with two questions. First, does this create the moat? Second, how often does it change? Those two answers put every module into one of three buckets.
- Moat plus high churn — keep it in-house, no exceptions. This is the logic that shifts every week because customers keep teaching you something. Outsource it and you are paying a vendor to learn your business well enough to be acquired instead of you. The institutional memory has to live inside your walls.
- Commodity plus stable — outsource it without guilt. Standard payment flows, admin dashboards, the internal tool nobody demos. These are solved problems with stable specs. Burning equity-holding engineers on them at Series B is a capital-allocation error your board can see in the burn multiple.
- Moat plus stable — embed, do not hand off. Proven features that just need to be hardened for 10x the load. This is where staff augmentation earns its keep: external senior builders commit to your repo, sit in your standups, and add throughput without adding permanent headcount you will have to right-size before the next raise. If you want the contract structure for this, we worked through it in staff augmentation vs. managed delivery.
The transferability premium nobody prices until diligence
Here is the part that separates a Series B build decision from an earlier-stage one: at Series B, transferability is no longer hypothetical. The next acquirer or growth investor will literally test whether your system survives without the people who built it. Documentation is the bridge from "rented hands" to "owned asset," and the only enforcement that works is a definition of done that refuses to merge a pull request without updated docs. If the vendor holds the knowledge, you are not selling a product in 18 months. You are selling a lease, and buyers price leases at a fraction of what they pay for assets.
What the code audit actually finds — and how to pass it
Series B is close enough to your next event that you should reverse-engineer the build decision from the diligence room. When a growth investor or strategic acquirer runs technology due diligence, they pull a code audit, but they are not grading elegance. They are pricing dependency risk. A repository whose entire commit history belongs to one external team, with no internal author behind the load-bearing services, gets a "replacement cost" line item. They assume they will re-hire and rebuild, and they discount the deal to cover it. The discount comes straight out of your multiple.
The wall most teams hit right before the raise
The market data on IT outsourcing is blunt: a majority of outsourced projects miss their strategic goals, and the cause is overwhelmingly governance, not raw engineering skill. For a Series B company the failure shows up as a velocity cliff — the moment the speed-optimized code becomes brittle enough that every new feature breaks two old ones, and throughput approaches zero. It tends to arrive around the same time you start prepping the data room, which is the worst possible scheduling.
So make the build decision now in a way that survives the audit later. The model that holds up:
- The architect is yours, full-time, with equity. A CTO or VP Eng who owns the standards, the architecture, and code review must be inside the company and incentivized to care about the codebase past the next sprint. This is the one role you never rent.
- The builders can be rented, but they play by your rules. Use agencies for execution, then make them commit to your repo, run your CI/CD, and show up to your standups. Their code goes through your review or it does not ship.
- Put a dollar figure on the debt and watch it weekly. Run shortcuts through our technical debt quantification framework so the cost is visible in real time. If a vendor is shipping fast while the debt line climbs, you are not saving money — you are pre-spending your next round's diligence discount, and you should change vendors before the cliff, not after.
The sourcing choice you make this quarter is the multiple you defend two years from now. Decide it like the buyer is already in the room, because at Series B they nearly are.
