Software / Insight
Custom Software or SaaS: How to Choose
Buying software and building software are different bets. The right answer depends less on budget than on how unusual your process really is.
Every growing business reaches a point where spreadsheets stop being enough. The question that follows is rarely "should we get software?" It is "should we buy something that already exists, or have something built for us?" The honest answer depends on your process, not on a preference for technology.
Start with the process, not the product
Before comparing tools, write down the process as it actually runs. Not the tidy version in a policy document, but the real one: who receives the order, who checks stock, what happens when a customer calls to change an address, which exceptions get handled by the person who has been there longest.
This matters because ready-made software encodes someone else's idea of a standard process. If your process matches that standard, the product will fit and you should probably buy it. If your process is the reason customers choose you, forcing it into a standard tool removes the advantage.
A useful test: count the exceptions. A process with two or three unusual steps can usually be handled inside a product with a workaround. A process where the exceptions are the daily work is a sign that you need something shaped around them.
When a ready-made product wins
Buy when the process is genuinely standard and the product is mature. Accounting, payroll, basic email marketing and standard point-of-sale all have well-worn solutions. Building these from scratch is rarely a good use of money, and maintaining them is worse.
- The process is common. Invoicing, ledgers, tax reporting and email all follow conventions that products already handle.
- The product has a support path. Someone else fixes bugs, handles compliance changes and keeps the thing running.
- Your volume fits the pricing. Per-user pricing is cheap at ten users and painful at two hundred.
- You can export your data. Leaving should be possible without rebuilding your history from screenshots.
There is no prize for building something that already exists. We have told clients to buy a product instead of commissioning a build, and it is the right answer more often than agencies like to admit.
When custom software earns its cost
Custom software makes sense when the system is part of how you compete, or when the integration work to bend a product into shape costs more than building the part you actually need.
- Your rules are unusual. Tiered pricing by route, subscription pauses, multi-branch stock transfers, commission structures that change by product line — each is possible in a product, until you need four of them together.
- The integration is the product. When your value comes from connecting stock, accounting, delivery and customer history, the integration layer is the thing worth owning. Products usually expose an API precisely so someone can build that layer.
- Per-user pricing punishes growth. If your model adds staff every season, a per-seat licence can become the largest software cost on the books.
- Data ownership matters. Some businesses cannot put customer records in a vendor's cloud, or need to keep operating when a subscription lapses.
- The workflow is the bottleneck. When one manual step consumes hours a day, a focused internal tool can pay for itself faster than a broad platform nobody fully adopts.
The middle path most teams miss
The choice is not only "buy everything" or "build everything". A common, effective pattern is to buy the commodity layer and build the layer that is specific to you. Keep accounting where it is. Keep email where it is. Build the operations tool that ties them together and matches your actual workflow, then integrate rather than replace.
This keeps the custom surface small and the maintenance cost low. It also means the first release can be genuinely useful: one workflow, used daily, connected to the systems that already hold the financial truth.
The questions that reveal the answer
- Can we describe the process in a way a new employee could follow? If not, no software will fix it yet.
- How many steps are genuinely unusual, and do those steps create value for customers?
- What would we do if the vendor doubled the price or shut down?
- Who will maintain this in year three — a vendor, an in-house team, or nobody?
- What is the cost of the current manual work, in hours and errors, per month?
- Can we run a small first release instead of a large one?
That last question is the most important. Software projects fail less often because the technology was wrong than because the scope was a monolith delivered as a surprise. A first release that replaces one painful workflow is easier to judge, easier to adopt and cheaper to change.
How we scope a first release
On a custom build we start by watching the work, not by writing a feature list. The output of that session is a short document: the steps the system will own, the steps that stay manual, the data that must move, and the definition of done for release one.
Then we build the smallest version that a real person can use daily. That usually means one role, one core workflow and a plain interface. Reports come after the data is trustworthy, not before. Integrations come when the workflow is stable, because integrating a process you are still changing wastes the integration.
Only after that first release is in use do we plan the next one. By then the team knows what the system is like to live with, which is information no requirements document contains.
What implementation actually involves
The build is one line in a project plan. Implementation is where most of the calendar goes, and it is the part a demo never shows.
If you are moving from spreadsheets, the data has to come across. That means profiling the old files, agreeing what counts as a duplicate, deciding what happens to incomplete records, and running a trial import before the real one. A dry run almost always reveals something the original list hid: a customer with two spellings, a product with no category, a price that was overridden by hand and never updated in the sheet.
Then people have to learn the system. Training is not a demonstration. It is sitting with the person who does the job and watching them do it in the new tool, fixing the screen that makes them hesitate. The first week is when the real requirements appear, because usage exposes the steps nobody thought to mention.
Documentation matters even for a small team. A short written record of how the system is structured, where it is hosted, how to restore a backup and who to call is the difference between an asset and a dependency. We write it during the build, not at the end, because writing it is how we notice what is still unclear.
None of this is glamorous. It is also the reason two teams can build the same feature list and end up with very different results.
What "custom" should include
If you do commission a build, make ownership explicit from the start. You should receive the source code, database access, hosting accounts and documentation. You should be able to leave. A vendor who holds the keys is a subscription in disguise, whatever the contract says.
Ask for a handover plan even if you never use it. The answer tells you whether the team is building you an asset or renting you access. Our own projects are set up this way, and we say so on the custom software page rather than burying it in a contract.
If you are weighing the two paths now, bring the messy process to a first conversation. We will tell you which side of the line you are on, including when the answer is to buy.
