Last spring a founder asked me to sit in on a meeting that he said would take twenty minutes. It was the classic build vs buy software debate. His head of operations wanted to buy a scheduling platform. His lead engineer wanted to build one. Both came with slides and numbers, and both were sure they were right. Two hours later nobody had changed their mind. Somewhere in the second hour I realized the argument had nothing to do with scheduling. It was about what the company believed it was good at.
Why I Use This Build vs Buy Software Framework
I’ve spent most of my career leading engineering teams. These days I work as a fractional CTO for companies that are too big to wing their technology decisions and too small to justify a full time executive to make them. The build vs buy software question comes up in nearly every engagement. Sometimes it’s a CRM, sometimes billing, an internal portal, a data pipeline, or the core product itself. The stakes vary, but the pattern rarely does. Smart people argue about features and price when the real decision lives somewhere else.
This guide is the framework I actually use with clients. It isn’t a vendor checklist, and it isn’t a pitch for custom development. I’ve told plenty of companies not to build, and I’ve told a few to stop paying for software they had outgrown. The goal is to help you make the call with your eyes open and then stick with it.
Why the Build vs Buy Software Decision Feels Harder Than It Should
Growing companies sit in an awkward middle. At ten people you buy whatever works and move on. At five thousand people you have procurement teams, architecture review boards, and a portfolio of systems that someone is paid to rationalize. Between those two points, from roughly fifty to five hundred employees, the decisions get expensive while the process for making them stays informal. For smaller firms, the first question is often whether custom software development for small business pays off at all.
Three forces make it worse.
First, engineers love to build. That isn’t a flaw. It’s why you hired them. But a capable team will almost always look at a commercial tool and see its limitations before its value. “We could do this in a sprint” is one of the most expensive sentences in business.
Second, buying looks deceptively cheap. A monthly subscription with a free trial carries none of the weight of a capital project. Nobody writes a business case for a tool that costs less than a team lunch per seat. Then the seats multiply, the integrations pile up, and three years later you’re running your operations on a product whose roadmap you have no say in.
Third, nobody owns the full picture. Finance sees the invoice. Engineering sees the code. Operations sees the workflow. The person who sees all three, and who has to live with the result, is often missing from the room. That gap is a big part of why fractional technical leadership exists at all.
The Question Underneath the Question
Before anyone opens a spreadsheet on a build vs buy software decision, I ask one thing: does the way you perform this function make customers choose you over a competitor?
Martin Fowler, chief scientist at Thoughtworks, described this years ago as the difference between utility and strategic software. His point was that the distinction isn’t really about the software. It’s about the business activity the software supports. If that activity is a genuine differentiator, the software behind it deserves your best effort. If it isn’t, you want it to work reliably and cost as little attention as possible, the same way you think about plumbing.
Fowler also noted something I see constantly in practice. Companies routinely overestimate how much of their work is strategic. He suggested the familiar 80/20 split may be closer to 95/5. Most of what a growing company does, including payroll, email, accounting, ticketing, document storage, and even most of its CRM, is utility work. It matters a great deal, but it doesn’t set you apart.
The Whiteboard Exercise
When I run this exercise with a leadership team, I put every major system on a whiteboard and ask them to sort it into two columns. The first pass almost always lands too many items in the strategic column. Then we go back through and ask a harder question: if a competitor used the exact same tool for this, would we lose a single deal? Usually the strategic column shrinks to two or three items. Those are where building deserves serious thought. Everything else starts with a strong presumption toward buying.
One more point from Fowler that people tend to forget: things that are strategic today can become utility later. Online payments were once a serious engineering challenge. Now you sign up for a processor and you’re live by the afternoon. Whatever you build should be reassessed as the market catches up. Systems that never get reassessed eventually turn into a legacy application modernization project.
Build vs Buy Software Costs: What Buying Really Costs
In any build vs buy software comparison, the sticker price of commercial software is the smallest part of what you pay. Here is what I tell clients to budget for.
Implementation and Integration
Most serious platforms need weeks or months of setup, data migration, and process redesign. Many companies hire a consultant for this, and that bill can rival the first year of licensing. If the new platform replaces an aging desktop system, plan how you’ll migrate legacy Windows applications and their data without disrupting the business.
The tool also has to talk to your other systems. Every connector is a small piece of custom software you now own, even though you “bought” the solution. When either side changes its API, someone on your team has to fix it.
Price Escalation and Unused Capacity
Vendors raise prices, change packaging, and move features into higher tiers. Your negotiating position weakens every year you depend on them more.
Unused capacity is bigger than most people expect. Zylo’s 2026 SaaS Management Index, built on data from more than 40 million licenses, found that organizations leave about 36 percent of their SaaS licenses unused when measured against recommended utilization levels. Those are seats paid for and never touched. When I audit a client’s software spend, shelfware is nearly always the first easy win.
Workflow Compromise and Exit Cost
This is the hidden one. When you buy, you adopt the vendor’s assumptions about how work should happen. For utility functions that’s often a gift, because their defaults reflect lessons learned across thousands of customers. For a differentiating process, it can quietly flatten the thing that made you special.
Ask any vendor how you get your data out, in what format, and how long it takes. If the answer is vague, treat that as a cost too.
Build vs Buy Software Costs: What Building Really Costs
If buying hides its costs in the fine print, building hides them in the future. This is the side of the build vs buy software ledger that gets underestimated most.
Maintenance Is the Real Bill
The initial development is a down payment. The real expense is everything after launch. ScienceSoft, drawing on its own maintenance engagements, puts maintenance at up to 90 percent of a system’s total cost of ownership for complex on premises software, and roughly 30 to 60 percent for cloud applications. Whatever the exact figure for your situation, the lesson holds. You aren’t funding a project. You’re adopting a product that will need care for as long as it exists.
Delivery Risk
McKinsey’s research with the University of Oxford, covering more than 5,400 IT projects, found that large IT projects ran on average 45 percent over budget and 7 percent over schedule, while delivering 56 percent less value than expected. Software projects carried the highest risk of overruns. The same research found that every additional year of project duration pushed cost overruns higher. Your internal tool isn’t a fifteen million dollar program, but the dynamics scale down. Optimism is built into almost every estimate I’ve ever reviewed, including my own.
Technical Debt and Opportunity Cost
There’s also the slow drain of technical debt. Stripe’s Developer Coefficient study found that developers spent about 13.5 hours of a 41 hour week dealing with technical debt, plus close to 4 more on bad code. More than half of respondents named legacy maintenance and technical debt as the biggest drag on their productivity. Every system you build adds to that load. An engineer maintaining your homegrown ticketing tool is an engineer not working on the product your customers pay for.
That trade off, the opportunity cost of your best people, is the cost I see underestimated most often. Building isn’t just expensive. It moves your team’s attention away from the work only you can do.
My Five Question Build vs Buy Software Test
When a build vs buy software decision lands on my desk, I work through five questions in order. Most decisions are settled by the third.
1. Is This a Differentiator?
Use the whiteboard exercise above. If the honest answer is no, buy unless something else on this list forces your hand.
2. Does a Mature Product Already Solve 80 Percent of the Need?
If several reputable vendors cover the core use case, the remaining 20 percent rarely justifies starting from scratch. Configure, extend, or change your process to fit. If nothing on the market comes close, that’s a strong signal in favor of building, or a sign your requirements need another look.
3. Do You Have the People to Build and Maintain It for Five Years?
Not just to launch it. To maintain it after the original developer leaves, which they eventually will. If the honest answer depends on one person, you don’t have the capacity. This is also where I push clients to write requirements down properly. A rational build or buy decision starts with clear requirements that you can measure options against, and you’d be surprised how many companies skip that step.
4. How Fast Do You Need It?
Buying usually wins on time to value. If a market window is closing or a compliance deadline is real, a good enough product live in six weeks beats a perfect system live in nine months.
5. What Happens If You’re Wrong?
Picture the failure in each direction. If you buy and outgrow the tool, how painful is the migration? If you build and the project stalls, what’s your fallback? Pick the path whose worst outcome you can survive.
When the Answers Conflict
If the answers point in different directions, the first question gets the most weight. A clear differentiator with weak internal capacity usually means building with outside help or a hybrid approach. In that case, choosing a software development partner becomes part of the decision itself. A utility function with a strong internal team still usually means buying, because that team’s time is better spent elsewhere.
The Build vs Buy Software Option Most Teams Skip
The usual framing of build vs buy software suggests two doors. In practice the best answer for growing companies is often a third: buy a solid platform for the commodity layer, then build a thin layer of custom capability on top where you actually differentiate.
Thoughtworks has written about this kind of thinking in its guidance on evaluating third party solutions. It describes the practice of keeping vendor products within clear boundaries so they don’t take over your architecture, and it uses Wardley mapping to show how capabilities move from novel to custom to product to commodity over time. The practical takeaway is simple. Let vendors handle what has become standard, and keep control of what hasn’t.
A Real Example: The Client Portal
A professional services firm I advised needed a client portal. Their first instinct was to build the whole thing: authentication, document storage, messaging, billing, and the scoping workflow that made their engagements unique. We bought identity management, used their existing document platform, and kept their billing system. Then we built only the scoping and proposal workflow, which was the part clients actually talked about when they referred new business. The custom piece was a fraction of the original scope and launched in a quarter instead of a year.
Keeping the Hybrid Disciplined
The hybrid approach has its own rules. Keep the custom layer thin. Integrate through documented APIs, not database hacks. And make sure the vendor underneath you is stable enough to bet on for the long run.
Running the Build vs Buy Software Numbers Over Five Years
Here is a simplified build vs buy software model I use to make the trade offs visible. The figures are illustrative, so swap in your own. Say you’re deciding on an internal operations platform for 60 users.
The Buy Scenario
$25,000 for implementation. Licenses at $45 per user per month, or about $32,400 in year one, rising 7 percent a year. Around $8,000 a year to maintain integrations. Over five years that comes to roughly $251,000.
The Build Scenario
$180,000 to develop in year one. After launch, about $36,000 a year in maintenance and enhancements (20 percent of build cost) plus $6,000 a year for hosting. Over five years that comes to roughly $348,000.
What Changes the Answer
On paper, buying wins by nearly $100,000. Now apply what we know about delivery risk. If the build runs 45 percent over budget, in line with the McKinsey average, the build scenario rises to about $429,000. That’s why it pays to know how to read a software development cost estimate before you trust the build number.
Then change one assumption. Suppose the company grows to 150 users by year two. The license line scales with headcount while the custom system mostly doesn’t. The buy scenario climbs to roughly $530,000 over five years, and suddenly building looks competitive even with an overrun.
That’s why I always tell clients to run the five year math on any build vs buy software choice, not the first year math, and to model at least three scenarios: expected, pessimistic, and fast growth. The answer often flips depending on which future you believe in. When it does, the money stops being the deciding factor and the strategic question from earlier takes over.
Costs People Forget to Include
- The salary cost of internal staff time spent on vendor management or development
- Training and change management for either path
- Security reviews such as an application security assessment, plus compliance audits and penetration testing
- The cost of eventually replacing the system, because everything gets replaced, and the end-of-support software risks you take on if you wait too long
Warning Signs You Made the Wrong Build vs Buy Software Call
Every build vs buy software decision ages. Here’s what I look for during a technology review.
You Bought Software, and You Should Have Built, If:
- Your team keeps building workarounds outside the tool, in spreadsheets or scripts
- Sales loses deals because of something the platform can’t do
- Customization costs with the vendor now rival what a build would cost
- The vendor’s roadmap keeps drifting away from your needs
You Built Software, and You Should Have Bought, If:
- One engineer is the only person who understands the system
- Feature requests pile up because the team is busy keeping it running
- A commercial product now does everything yours does, for less
- Nobody can explain how the system makes you more competitive
Neither list is a reason to panic. Both are reasons to put the decision back on the agenda. If a system you built has drifted, decide whether to rewrite or refactor legacy code before you rule out keeping it.
How AI Coding Tools Change the Build vs Buy Software Math
Every client now asks me some version of the same question. If AI assistants make developers faster, doesn’t that tilt every build vs buy software decision toward building?
Partly. AI tools have made it cheaper to produce a first version of internal software, and I’ve watched small teams ship useful tools in days that would have taken weeks a few years ago. For narrow, low risk utilities, like an internal dashboard or a data cleanup script, that changes the calculation in a real way.
Where the Costs Still Sit
But look at where the costs actually sit. Initial development was never the biggest expense. Maintenance, security, integration, and the long tail of edge cases are, and those haven’t shrunk in proportion. If anything, faster code generation makes it easier to produce more software than your team can responsibly maintain. I’ve started seeing what I call prototype sprawl: a dozen small internal tools, each built quickly, none with a clear owner. Each one quietly becomes another legacy system, and securing legacy applications nobody owns is a job nobody wants.
My advice is to let AI lower the cost of experiments, not the bar for ownership. Build a prototype to test whether a custom approach is worth it. Then run the same five question test before you commit to running it in production.
Making Your Build vs Buy Software Decision Stick
The last part of the process is the one most companies skip. Once you decide, write it down.
Keep a Decision Record
I ask clients to keep a short decision record for every significant build vs buy software choice. One page is enough. It covers what you decided, the alternatives you considered, the assumptions behind the numbers, and a date to revisit it. Twelve to eighteen months is usually right for anything that isn’t core to the product.
This does two things. It ends the endless reopening of settled debates, because anyone who wants to revisit the call has to show which assumption changed. And when an assumption really does change, such as headcount doubling, a vendor getting acquired, or a new competitor appearing, you know exactly which decisions to look at again.
Assign an Owner
Bought tools need someone accountable for adoption, licensing, and the vendor relationship. Built tools need a product owner, not just a developer. Software with no owner gets worse over time whether you bought it or built it.
The Bottom Line on Build vs Buy Software
The build vs buy software decision isn’t really about software. It’s about focus. Every company has a limited supply of attention, engineering capacity, and leadership bandwidth. Spend those resources on the few things that make you different, and buy everything else from people who have already solved it.
When you do build, build with clear eyes about the five year cost and the people it will take. When you buy, buy with an exit plan and a careful count of seats. And when the answer is unclear, the hybrid path of buying the core and building the edge is usually where the smartest growing companies end up.
That two hour meeting about the scheduling platform ended with a decision to buy. The engineer was disappointed for about a week. Then he spent the next quarter building the pricing engine that now wins most of the company’s competitive deals. That was the right place for his talent all along.
Frequently Asked Questions
What is the build vs buy software decision?
Build vs buy software is the choice between developing software in house, or with a development partner, and buying or subscribing to an existing commercial product. For growing companies it usually comes down to cost, speed, control, and whether the function sets the company apart. The Thoughtworks build vs buy guide is a useful deeper read.
When should a company build custom software instead of buying?
Build when the software supports a real competitive differentiator, when no mature product covers most of your needs, and when you have the people to maintain it for years. Martin Fowler’s utility vs strategic dichotomy is a helpful lens for telling the difference.
Is it cheaper to build or buy software?
Buying is usually cheaper in the first year, but the answer can flip over five years depending on user growth, price increases, and integration costs. Building carries heavy maintenance and real delivery risk. McKinsey’s research on large IT projects found average overruns of 45 percent.
What hidden costs come with buying SaaS?
Implementation, integration upkeep, price escalation, workflow compromises, exit costs, and unused licenses. Zylo’s 2026 SaaS Management Index found organizations leave about 36 percent of licenses unused against recommended utilization levels.
How much does it cost to maintain custom software?
It varies a lot by system, but maintenance typically makes up the largest share of lifetime cost. ScienceSoft’s analysis of maintenance costs puts it at up to 90 percent of total cost of ownership for complex on premises software, and roughly 30 to 60 percent for cloud applications.
Can a fractional CTO help with build vs buy software decisions?
Yes. A fractional CTO brings an outside, cross functional view of finance, engineering, and operations without the cost of a full time executive. They can run the build vs buy software analysis, challenge internal bias in either direction, and set up a decision process the team can reuse.
References
- McKinsey & Company: Delivering large scale IT projects on time, on budget, and on value
- McKinsey & Company: Unlocking the potential of public sector IT projects
- Martin Fowler: Utility Vs Strategic Dichotomy
- Thoughtworks: Build vs. Buy, A Strategic Framework for Evaluating Third Party Solutions
- Stripe: The Developer Coefficient
- Zylo: 2026 SaaS Management Index
- ScienceSoft: Software Maintenance Costs
- CIO: How to Determine When to Build or Buy Enterprise Software