Build, Hire, or Subscribe

You've read twelve chapters arguing that what you're missing isn't a title, it's reliable execution: the five accountabilities, delivered week after week, measured by the ten KPIs. Fine. Now you have to actually do something. There are three doors, and you'll walk through one of them whether you choose deliberately or by default.

Door one: build an in-house team. Door two: hire a CTO, full-time or fractional. Door three: subscribe to the execution and skip the org-chart question entirely. Each one buys you something different, and each one costs differently. Let's price them honestly.

Door one — build the team

This is the instinct most founders trust, because it feels like control. You hire engineers, they sit on your payroll, the code is yours, the people are yours. The trouble starts with the bill, and it's bigger than the salary line you're picturing.

The average US software developer earns about $154,076 a year (US Census/BLS via DataUSA, 2024). That's the wage. It is not the cost. Benefits run to roughly 29.9% of total compensation for private-industry workers (BLS ECEC), which puts the fully-loaded figure at about 1.43 times base. Do that multiplication and one developer costs you in the region of $220,000 a year, or about $18,000 a month. One developer.

A single developer is not a team and it isn't an accountability owner either. You need at least two or three to cover delivery, plus someone to own quality and reliability, plus someone deciding what gets built. Stack three or four loaded engineers and you're past $700,000 a year before anyone has reviewed a line of code. And you carry that cost from the day each contract starts, not from the day the first feature ships.

Then there's the wait. Hiring is slow and getting slower: across all roles, time-to-fill rose from 43.6 days in 2022 to 59.7 days in 2025, a 37% jump (Greenhouse). That figure covers every kind of job, not engineering specifically, so read it as direction rather than a precise number. Senior engineers are not faster to land than the average. Two months to fill one seat, and you still have to onboard, integrate, and hope the hire was a good one. If it wasn't, you eat the first-year salary plus the ramp time plus the cost of starting over.

Build is the right door when engineering is the business and you intend to run it at scale for years. For a growing company that mostly needs things to ship, it's a heavy, slow, expensive way to find out whether your hires can execute.

Door two — hire a CTO

So you skip the team and reach for a leader. Get the right person at the top, the thinking goes, and the team and the shipping follow.

A full-time technology leader is a serious line item. The official proxy, a US Computer and Information Systems Manager, averages about $155,405 a year (US Census/BLS via DataUSA, 2024), and the same 1.43 loading applies on top. At the senior end the market runs far higher. That buys you strategy, hiring, architecture decisions, a single accountable name. What it does not buy you, on its own, is a working team underneath that name. A CTO with no engineers to direct is an expensive way to produce slide decks.

The fractional version answers the cost objection. A fractional CTO gives you a fraction of a senior leader's time for a fraction of the price, and one vendor estimate puts it at 40 to 60% less than a full-time hire (vendor figure, treat as a range). The model is real and it has real uses. Read what fractional vendors say it is, though, in their own words: a fractional CTO "leans more heavily toward strategic guidance, oversight, and experience while eschewing the leadership role of managing teams" (gofractional). That sentence is the whole problem in one line.

Strategic guidance is advice by the hour. It is not hands on keyboard. A fractional leader can tell you the roadmap is wrong, the architecture won't scale, the hire was a mistake. All useful. None of it ships software, because the person giving the advice has explicitly stepped back from running the people who would. You've bought a diagnosis and left the treatment unfunded. That distance between sound advice and working code in production is the execution gap, and a part-time advisor sits on the wrong side of it by design.

Hire is the right door when you have a team that ships but lacks direction, or when the strategic call genuinely is the bottleneck. If nothing is reaching production, a CTO of either kind is a title filling a seat. You went shopping for an org-chart fix and you'll come home without any shipped software.

Door three — subscribe to the execution

The third door asks a different question. Not "who do I put in the seat," but "how do I get the five accountabilities delivered, on a cadence, without owning the headcount or the hiring risk."

That's subscription engineering. You pay a flat monthly fee for engineers who deliver task-based work, you approve each task before the next one starts, and you can stop when you no longer need it. There's no two-month hire to wait out and no severance to plan. The execution is the product, not a by-product you hope your hires produce.

This is Dev on Demand, and the chapters ahead spell out exactly what it covers. Here it earns one row in a table. The point of the comparison isn't to crown a winner for every company. It's to show you what each door actually delivers against the thing you came for, which is reliable execution.

The three doors, side by side

Read the table the way you'd read a board pack. With Build, you get people, along with the long and costly job of managing them. With Hire, you get a name at the top, and if it's fractional, advice that stops short of running anyone. Subscribe is the column that hands you the shipped work itself. So if the thing you're short of is execution, only one of these three is actually selling it.

None of this is a case against ever building a team or ever hiring a leader. Both are right for some companies at some stage. The question this book has pushed you toward is narrower and more useful than "which is best." It's this: which door puts working software in front of your customers, predictably, starting next month? Price the doors against that, and the choice gets a lot clearer.

Next: pulling the whole spine together. The title you never needed, and the execution you did.