Build or buy? A decision framework for small and mid-sized companies

"I know an engineer. He says he could build this in two or three months." Most owners get the build-or-buy question wrong from the start. It isn't either-or. It's "which parts to build, which parts to buy." This post gives you three axes you can apply on the spot: is this a source of your competitive edge, do the rules keep changing, and who maintains it five years from now. It also breaks down, honestly, why the most expensive part of building was never development.

Johnny Yang12 min read
Build or buy? A decision framework for small and mid-sized companies

"I know an engineer. He's seen our workflow and says he could build this in two or three months. So why would I buy something off the shelf?"

I've heard this in meeting rooms more than once. The person saying it usually isn't clueless. He has actually done the math. He's seen the demo, gone through the feature list, and concluded that half the features in the packaged software are useless to him, and the other half don't quite match how his company works. If he's spending money anyway, why not pay someone to write a system around his own workflow? It sounds perfectly reasonable.

I'm Johnny Yang, Brightstream Technology, Taiwan. I've led implementation work for seven years, across 252+ projects in 32+ industries. I've been asked this so many times I'm numb to it, so here's the conclusion up front: "Build or buy" is the wrong question, because it assumes one answer for the whole company. The companies that make it work split their systems into several pieces and answer for each one separately. Build the piece where your competitive edge lives. Buy the piece tied to regulations and external standards. Connect everything in between through integration. Deciding build or buy for each piece takes only three axes: is this the reason you beat your competitors, do the rules for this keep changing, and who maintains it five years from now. The third is the one fewest people ask, and it's the one that ends up killing the company. Because the expensive part of building was never development. It's maintenance. Development is paid once. Maintenance is paid every year, and it gets harder to pay as time goes on.

First, you're right: you won't use half of a packaged system

I'm not going to start by talking you out of building, because your observation is correct.

Any software sold to an entire industry is, by nature, "the union of a hundred companies' requirements." You open the feature menu and see multi-language, multi-currency, multi-plant, dual lot-and-serial traceability. Then you look at your own company: one plant, one currency, no use for lot numbers. You feel like you're paying for other people's requirements. That feeling isn't imagined.

The other half stings more. Packaged software forces you into its workflow. It says a quotation needs a customer record first, the customer needs to pass a credit check first, a shipment needs an order first. But at your company, the owner might settle things with the customer on LINE and tell the sales support staff to ship right away, with the paperwork filled in the following week. At that point the software isn't helping you. It's arguing with you.

So "I'll build one that fits my workflow exactly" isn't a wrong starting point. What's wrong is the assumption hidden inside it: that fitting the current workflow equals solving the problem. The failures I've seen most often on site start exactly from that assumption.

But this isn't either-or. It's "split it up and answer each piece"

Ask the question again. Don't ask "should I build or buy." Ask "which parts of this company should I build, and which should I buy."

Take a company that distributes and repairs equipment. Its daily work splits into several pieces: inventory and accounting, quotations, repair dispatch and field reporting, maintenance cycle tracking, and filings to regulators and the tax authority. These pieces are very different in nature. Accounting and filings follow rules the government sets, the rules change every year, and they're the same for every company in Taiwan. Any "special touch" you add there is just trouble. Buying is the only answer. Repair dispatch is different. If customers chose this company precisely because "a technician shows up the same day and knows which part to bring before arriving," then that piece is its lifeline, and its decision logic won't look like any off-the-shelf software.

Same company, two pieces, two answers.

Most people treat it as a single-choice question because they're picturing "one system." What you actually need isn't one system. It's a set of things that talk to each other. So when you evaluate options, don't just check the feature list. Ask whether the data can get out, and whether it can connect.

Three axes: ask them of each piece of your workflow

Once the workflow is split, run each piece through these three questions. They're short. Answer them honestly.

First: is this a source of your competitive edge. You don't decide this by how you feel. Ask your customers why they chose you. If the answer is "your quotations are fast," "your scheduling is accurate," "you'll take small rush orders," then that workflow is your asset and worth controlling yourself. If you can't get an answer, you have nothing unique in that piece, and insisting on building it just rebuilds what every competitor already has. In my projects, most owners overestimate how unique their workflows are. What you think of as "we do it differently" is often just "no one here has ever rethought this." Those are not the same. The first should be kept. The second should be cut during implementation.

Second: do the rules keep changing, and who sets them. If the rules are set externally (tax rules, invoice formats, e-filing interfaces, e-commerce platform APIs, regulators' forms), building it yourself means signing an open-ended contract to keep catching up. Every time they change, you change. No negotiation. When you buy, what you're really paying for is "someone watching the updates for you." Flip it around: if you set the rules yourself and adjust them often to win business (how discounts are calculated, how sales commissions work, how rush jobs jump the queue), then buying a package means asking the vendor for a change every time you make one. Eventually you're trapped inside your own system.

Third: who maintains it five years from now. I always ask this, and clients usually pause. Not who builds it now. Who maintains it in five years. For the piece you plan to build, does anyone in the company understand it? Is it only one person? If that person quits, gets poached, or just wants a long vacation, will anyone still dare to touch it? If the answer is "oh, that's so-and-so," and there's only one so-and-so, you're not building a system. You're building a time bomb.

AxisLeans buildLeans buy
Is it a source of competitive edgeThe reason customers say you beat competitors sits in this pieceCompetitors all do it about the same; nothing special about yours
Who sets the rules, do they changeYou set the rules and change them often to win businessRules are set externally (tax, regulation, platform interfaces)
Who maintains it in five yearsDedicated people in-house, and more than one person understands itNo one dedicated; once it changes hands, no one dares touch it

The three axes aren't a vote. The third has veto power. No matter how strongly the first two point to building, if you can't answer the third, that piece should not be built in-house.

The most expensive part of building isn't development. It's maintenance

This is the most important section of this post, and the one you won't find in any proposal.

Development is a one-time thing. You agree on scope, find someone, they finish, you sign off. It has an end date. Maintenance doesn't. And the burden isn't flat. It climbs over time. There are several reasons, and I've seen every one of them on site.

First, the person who wrote it leaves. This has nothing to do with character. Engineering careers move. When he leaves he doesn't take the code, but he takes every judgment that was never written down: why this extra field exists, why this status can't be skipped, which customer that odd exception was built for. The next person inherits a pile of logic that runs but no one knows why. So he doesn't dare change the old code and writes a new version alongside it. Two years later you have two sets of logic doing the same thing, and no one knows which one is right.

Second, the foundation ages. A system doesn't live in a vacuum. It sits on an operating system, a database, a language version, and a pile of third-party packages, and every one of those updates every year while old versions lose support every year. Leave it alone and it breaks on its own. Keeping up means someone has to upgrade it regularly, and upgrades produce nothing anyone can see. That's exactly the kind of work that never gets scheduled. So it gets pushed off until it can't be pushed any further, and then it becomes major surgery.

Third, requirements keep growing, and building has no brakes. When you buy, adding a feature means negotiating with the vendor. That friction is annoying, but it filters your requests. Building has no such gate. A salesperson casually asks "can we add one more field," and it's there the next day. Three years later you have a form full of fields, and no one remembers which ones are still used. This kind of rot is silent. By the time you notice, it's usually hard to save.

Fourth, accountability gets blurry. When something you bought breaks, you call and open a ticket, and the vendor is obligated to deal with it. When something you built breaks, your own people carry it, and your own people also have their real jobs to do. The shipping system goes down at midnight. Who do you call? If you don't have a clear answer to that, your build plan is missing a whole piece.

I'm not saying this to scare you off building. I'm saying it so that on the day you decide, you put maintenance into the math. An honest build decision sounds like this: "I'll build this piece myself, and I accept that from now on I budget maintenance staff for it every year and make sure at least two people understand it." If you can't say that sentence out loud, you already have your answer.

The cost of buying: you're buying someone else's assumptions about your workflow

To be fair, buying has a cost too. It just has a different shape.

When you buy a system, you also buy its designers' understanding of your industry: how many stages a document should go through, who approves whom, at what point inventory gets deducted. Some of those assumptions help you. They're usually practices the industry built up over years, and they're better than your homegrown version. Others collide head-on with how you actually operate.

When they collide, most people's instinct is "then change it." This is exactly where buying spins out of control. A few changes are fine. Change it until the core logic is overturned, and you end up with something that looks like a package on the outside and is a custom build inside. You get none of the flexibility of building, and you lose the most important value of buying: upgrades. I wrote a separate post on how to put the brakes on custom-built work, so here's just the rule: spend custom-built effort on "the piece where you really are better than competitors," not on "the way we've always done it."

The other cost is psychological. When you buy, you're forced to change part of how you work, and that's ten times harder than installing software. There's no shortcut, and building doesn't let you escape it either. Building just postpones the pain until three years later, when you discover the system has locked your bad workflow in place completely.

When you should do neither

I'll say it: for some companies, the best choice right now is to do neither yet.

If you can't explain how your own workflow runs (three people do the same task three different ways, each department reads the same document fields differently, inventory numbers never match the physical count), then building or buying just moves the mess somewhere more troublesome. Get the workflow to the point where it fits on one sheet of paper. Then talk about tools.

The other case is being drawn in by the word "free," thinking a no-cost system can't hurt to start with. I've broken down that math before. The real cost of free systems usually lands where you can't see it: your data can't get out, no one is responsible, and when something breaks there's no one to ask. The same logic applies exactly to building. A system written by a friend as a favor carries the same kind of risk as free software. The shared problem is that "no one is obligated to still be responsible for it five years from now."

So what should you do tomorrow

Don't call a meeting to discuss "should we build it ourselves." You can hold that meeting ten times and never reach a conclusion, because the question itself is wrong.

Do three things tomorrow. First, take a blank sheet of paper and split the company's daily work into five to eight pieces, with one sentence describing what each piece does. Don't write department names. Write the work. "From a customer asking for a price to the quotation going out" is far more useful than "Sales Department."

Second, ask each piece the three questions: would customers choose us because of this, who sets the rules, who maintains it in five years. Write down the answers piece by piece. You'll find most pieces are out at the first question. They're not your competitive edge, and their rules aren't yours to set. Put them straight on the buy pile and stop agonizing.

Third, take whatever landed on the build pile and ask a harder question: who understands this right now? Only one person? What happens if that person hands in a resignation tomorrow? If you can't answer, move it to the buy pile for now. What actually passes is usually much less than you expected at the start. Those few pieces are the only ones worth putting your own resources into controlling.

Once you've done these three things, you no longer have the vague question "should we build it ourselves." You have a sorted list. Whatever the list looks like, that's your answer. If you've split things up and aren't sure the sorting is right, have someone who's done this at dozens of companies walk through it with you once. A free 30-minute diagnostic is usually enough to get the direction clear.

Found this useful? Pass it on
Prices published · free range estimate

So what does a build to your process actually cost?

From NT$300,000, priced against your spec, with same-scope changes free during the maintenance period. The prices and the estimator are in the first screen — get a range first, you do not have to decide anything yet.

Written scope, then a fixed price · staged acceptance · the code and the data are yours · or just book a free 30-minute diagnostic

Johnny Yang (熊董)
Johnny Yang (熊董)
Founder, Brightstream Technology

Serial founder leading a small team that builds systems into an owner's everyday work.

As a founder
7 yrs
Projects delivered
252+
Industries served
32+
About Johnny