Deciding whether to build vs buy software solutions is one of the central challenges for IT procurement teams. Each time we encounter a need for a new tool, capability, or other software asset, we’re faced with this decision.
The trouble is, there are a lot of moving parts at play here.
You see, on one level, this simply comes down to maximizing return on investment. However, so many different factors influence cost-effectiveness that it can be hard to know where to start.
As with any major investment, it’s important to take an empirical, analytical approach.
Therefore, we need to have the right framework in place. More specifically, we must thoroughly understand the exact variables and concerns that feed into build vs buy decisions for software.
After this, we can then think about the process we can follow to apply this in more specific situations.
Today, we’re covering everything you need to know. We’ll also see how the game is changing, thanks to new and evolving development tools.
But first, let’s start with the basics.
What is a build vs buy decision?
As you can probably guess, the idea of build vs buy is figuring out whether you can achieve better results and/or lower lifetime costs by developing a custom solution or simply purchasing an off-the-shelf tool for a given use case.
This is a lot easier said than done. In fact, it’s a deceptively complex process.
The issue is that we need to draw on a combination of technical, financial, and operational concerns, for any given solution, as well as analyzing the suitability of the actual tools that are on the market.
We’ll return to each of these factors in more detail in a second.
First, let’s think more deeply about what our ultimate goal is.
Essentially, the key challenge is determining where we’ll see the best return on investment. Where this becomes problematic is the fact that it draws on so many other issues besides the actual direct cost of the solution.
With that in mind, we need to thoroughly drill into the factors that feed your decision when it comes to whether to build vs buy software.
When to build vs buy software: decision points
In truth, build vs buy decisions are informed by a wide range of factors, including direct and indirect costs, operational and legal issues, taxation, market analysis, the nature of the required end solution, and more.
This is a lot for procurement teams to get their heads around, whatever the size of your company.
With that in mind, here are the most common decision points you’ll need to think about.
Is it cheaper to build vs buy software?
It’s actually very difficult to make a broad comparison of direct costs, for a couple of key reasons. One is that the way costs are structured is so different. Another is that there’s a huge variance in the costs of custom builds.
Then we have to account for indirect costs too.
Let’s start with how costs are incurred.
Nowadays, most off-the-shelf platforms follow an SaaS model. That is, you pay an annual or monthly subscription fee, normally on a per-user basis. So, we have a regular, relatively fixed cost - but we incur it for as long as we need the platform.
By contrast, custom builds involve more front-loaded costs - primarily in the form of development hours and labor. This normally comprises in-house developers’ wages or fees from vendors.
However, this is problematic, as so many builds go hugely over budget. Plus we need to factor in indirect costs, ongoing support, and maintenance, as well as project-related risks.
Really, cost comparisons are highly contextual.
As we’ll see when we look into our other key decision points, we need to set this against other factors that determine the profitability of a specific solution.
Do you really need a custom solution?
This seems like it should be an obvious question, but it’s also an issue where a lot of businesses end up kidding themselves. Our first task is figuring out if there’s a solution already on the market that adequately meets our needs.
The thing to recognize here is that some business processes are unique to your company, but many of them are also pretty generic. Even these might have some variations around the edges, but in terms of substance, they’re still not unique as such.
Therefore, what we need to assess is whether there’s a solution out there that either maps to our processes out-of-the-box or offers sufficient adaptability to do so with a little bit of tweaking and configuration.
We can look to a few key points here.
One is integrability. Nowadays, it’s pretty rare that we’d see workflows that don’t pull in resources from multiple platforms or data sources. For efficiency, we need to know that individual tools in our software stack are compatible.
So, we can eliminate any off-the-shelf tools that don’t offer the integrations we need, straight off the bat.
Beyond this, we can also think about more specific features and functionalities. For instance, you might have very particular requirements across hosting and deployment, building automations, data processing, security, or customization more generally.
Again, if these are must-haves, solutions that don’t support them aren’t going to be viable, so they can be eliminated from the running.
Take a look at our round-up of in-house development examples for inspiration.
Do you have time to build vs buy software?
Sometimes, we need solutions live yesterday. This presents a big challenge for IT teams. On one level, you’ll need to ask yourself if you actually have the time to build a custom solution.
We can divide this into two issues.
First, whether or not we have the development resources to build a particular solution internally. Second, whether or not our development team has the capacity to turn it around as quickly as we need them to.
Traditional custom builds take a long time - typically months or even years. However, we’ll see a little later how low-code development is changing the equation here.
(Good Firms )
On the flip side, there isn’t much point in implementing a solution quickly if it’s not suitable in the first place. In the case that no off-the-shelf solutions are viable, you might have no choice but to build your own.
Of course, there will always be cases that fall into more of a grey area. For instance, if there’s a tool on the market that goes 90% of the way toward meeting your needs, then compromising in the immediate term might be the most viable option.
How do we ensure scalability?
Another important pain point is that what we need today might not have much in common with what we’ll need tomorrow. Therefore, we need to account for scalability when thinking about whether to build vs buy software.
This comes in two flavors.
First, vertical scalability. This means increasing capacity or resources within an existing aspect of the solution. For instance, adding users, database entries, or performance-related optimizations.
This isn’t difficult to achieve with either type of procurement, but when you use off-the-shelf tools, you could end up being faced with ballooning licensing costs, depending on how your bill is calculated.
Second, there’s horizontal scalability. This is when we add entirely new features, screens, functionalities, processes, access roles, or other elements to an existing tool.
This is a much trickier prospect.
On the one hand, with off-the-shelf solutions, we’ll need to wait for vendors to release features we need - unless we’re a particularly high-ticket client. Customization can get us pretty far here, but we can’t rely on this all of the time.
If our needs diverge from what the product can offer, we’re back to square one.
On the other hand, there’s the obvious issue that if we want to add functionality to a tool we built ourselves, we’ll have to do it ourselves. So, we’re incurring additional development costs.
There’s no straightforward way through here, sadly. Predicting our future needs is hard enough. Deciding what’s going to be the most cost-effective strategy to meet them is even harder.
Ownership, licensing, and legal considerations
We can also step away from technical issues and think about more business-level decision points.
There’s an awful lot to unpack here, so we’ll take each of the top priority issues in turn.
Let’s start with ownership. When you build a solution, it’s your intellectual property. This isn’t a priority for every business, but it’s critical for others. For instance, in an enterprise context or other situations where a particular solution is highly mission-critical.
Naturally, ownership comes along with the power to control exactly how your tool is built, deployed, used, and managed.
The flip side of this is that we absorb a greater number of liabilities, relating to risk, maintenance, support, incident responses, and administrative work.
By contrast, with off-the-shelf solutions, we’ll often rely on vendors for these things, through SLAs or as part of our license. However this isn’t necessarily the case, so thorough vetting is needed to understand where liabilities fall.
Then we have more specific legal issues, which are obviously difficult to generalize about.
For example, there might be highly specific tax implications in your jurisdiction for custom internal builds. You’ll also need to consider how complying with different local privacy laws will impact your decision, including any costs associated with this.
Finally, if you become dependent on an off-the-shelf solution, you’re more likely to encounter vendor lock-in, where you’re vulnerable to price increases, end-of-service, or other risks.
Factoring in your project’s scope
The scope of your required solution will also play a huge role in determining whether it’s better to build vs buy software. There’s a direct relationship between the scope of a project and the development resources that it’s going to require.
Therefore, this is an important decision point when trying to determine if an internal build is the most viable option. We can actually point to some pretty useful trends here that apply to most companies.
Over a certain threshold of complexity, building rather than buying software can become a less attractive prospect. For instance, it would be rare that you’d build your own CRM or ERP software unless you had very specific requirements that aren’t available off the shelf.
But in most cases, the benefits of doing so over opting for an off-the-shelf solution just aren’t likely to overcome the costs.
Indeed, most of the tools that businesses end up building instead of buying are relatively simple from a technical perspective but highly tied to specific internal tasks and workflows.
Check out our ultimate guide to in-house software development for more information.
Hosting, deployment, and security
Finally, we can think about how build vs buy decisions for software are influenced by your requirements around hosting, deployment, and security. Again, the extent to which this plays a role varies massively from business to business.
Having the ability to self-host is often a red line for large, security-conscious organizations, which will rule out many SaaS platforms. We can see the same effect with support for specific devices, OSs, and environments.
Regardless of the size of your business, having the power to implement specific security measures can also be a red line. For example, you might want to use your existing SSO and authentication tools.
Besides this, you might opt to build vs buy software purely on the basis that there’s an inherent risk in increasing the number of actors and nodes involved in any project or system.
So, many times, businesses will opt to build rather than buy solutions as it eliminates risks associated with vendor-side incidents, including data breaches or service interruptions.
Building custom solutions: pros and cons
With a firmer idea of the key factors that go into build vs buy decisions, we can move on to a more detailed discussion of when and why you’d want to opt for both options.
This will also help us to shine a light on the different scenarios where you’ll typically go for one option or the other.
Let’s start by thinking about the broad pros and cons of building custom solutions.
We’ve already hinted at many of the key points here, so we can simply summarize to crystalize the specific benefits of building solutions rather than buying them.
Here are the key points:
- Customization - You have the ability to build the exact solution you need,
- Specificity - You can achieve a much closer degree of process mapping.
- Integrability - You can ensure that your solution integrates with your software stack.
- Ownership - Your solution is your intellectual property.
- Control - You have total control over your solution across its entire lifecycle, including scalability and modifications.
- Independence - You’re not dependent on decisions made by external parties or events that impact their business.
In other words, we’ll normally turn to custom builds when we need either a very specific solution or when we need a more generic solution but we have a business-level reason for maximizing our control over the solution.
Then, of course, there’s the obvious scenario where a suitable off-the-shelf solution simply doesn’t exist.
Of course, we also know that custom builds are far from plain sailing. Indeed, we’re going to encounter a whole range of financial, technical, and operational challenges. Often, these can be prohibitive, especially when it comes to traditional hard-coded solutions.
- Cost - Custom builds incur relatively high upfront costs.
- Risks - You’re more likely to encounter a range of risks, including overspending, scope creep, or even never achieving a viable solution.
- Delays and roadblocks - Custom builds take longer to implement than off-the-shelf tools and are more likely to encounter delays along the way.
- Additional responsibilities - When we build our own solutions, we also assume responsibility for maintaining, supporting, and managing them.
These are serious challenges. And that’s assuming that you even have the knowledge, skills, and capacity to build tools internally in the first place.
Check out our in-depth guide to in-house vs outsourcing software development .
Buying software: pros and cons
Next, we can turn our attention to the more specific reasons why you might opt for an off-the-shelf solution.
Then, we’ll look at some of the challenges that come along with this.
First up, the benefits. As you might expect, they relate to convenience to a very large extent.
The most important points to note include:
- Cost - In most situations, the up-front costs of off-the-shelf solutions will be lower.
- Speed - When you buy software, it can be implemented pretty much immediately.
- Convenience - Undoubtedly, off-the-shelf tools are much more convenient.
- Predicability - We know exactly the solution we’re getting with off-the-shelf tools.
- Usage-based pricing - Most Saas platforms charge on a usage basis, so costs are proportionate to our needs.
So in other words, buying off-the-shelf tools is typically a fast, cost-effective option, at least assuming that a suitable platform exists.
However, we’ll also normally need to compromise to some extent or customize tools to properly fit our requirements.
In fact, there are a number of reasons why off-the-shelf solutions can be less than ideal. On one level, we have the issues of achieving the right functionality, but there are also operational, legal, and financial concerns to consider.
The primary drawbacks include:
- Lifetime costs - We must continually pay for software licenses for as long as we need each platform.
- Dependence - We’re dependent on vendors for ongoing support, maintenance, and lifecycle management.
- Lack of customization - Platforms might not offer sufficient customization to meet our needs.
- Additional risks - Buying software introduces a range of new vendor-side risks.
- Incoherence - If we work with a number of vendors for different tools, we can encounter compatibility issues and incoherent user experiences across our software stack.
- External ownership - The tools we use aren’t our intellectual property - they’re owned by the vendor.
As you can see, some of these issues are closely related to finding appropriate tools in the first place, whereas others are largely non-technical, including legal, financial, and operational issues.
How to make a build vs buy decision: step by step
One important reason to have a firm grasp of the respective pros and cons of building vs buying software is that we’re better positioned to decide which of these apply to us.
For instance, you may have read some of the points we made above and thought that they simply aren’t issues for you. Internal ownership may not be a priority in the context of a smaller organization, for example.
Therefore, we need a robust, systematic approach to weighting and analyzing the pros and cons of building vs buying software.
Here are the specific steps you can follow to make an effective build vs buy decision for software solutions.
1. Analyze your requirements
The natural starting point here is analyzing your requirements - both technical and non-technical. So, we can start with the specific problem that we need to solve, either by building or buying software.
We can break this down into a few more discrete levels:
- Functional requirements - What we need our solution to do, including specific functionalities, integration options, automation features, and more.
- Non-functional requirements - Technical issues outside of the solution’s core functionality, including those relating to user management, performance, security, hosting, and deployment.
- Business-level requirements - Issues relating to the legal, financial, and operational implications of using a particular solution, including your relationship with vendors and, importantly, your budget.
The first step is simply listing your requirements under each of these clusters. We can then think about how we rate each of them in terms of their relative importance.
A simple approach here is to categorize each individual requirement as a must-have or a nice-to-have. Alternatively, you might use a numerical scoring system.
Or, every one of your requirements could be just that - a red line.
By the end of this exercise, we should have crystalized exactly what we need our end solution to do and how.
That way, we can start assessing our options.
2. Survey the market
Obviously, when weighing up whether to build vs buy software, we need a clear picture of what’s out there already. Specifically, we need to do two things. First, identifying potential solutions.
Second, assessing and validating the suitability of each against our requirements.
The key is to take an empirical approach here.
We can achieve this by scoring each of the options we’ve identified against the granular requirements we identified in the previous step and their relative importance.
So, if you opted for a must-have/nice-to-have system in the previous step, we might simply score potential solutions on how many requirements they meet under each category.
If we used a more detailed ranking system, we’d need to score solutions accordingly.
Alternatively, where there’s less flexibility in some or all of our requirements, we might take more of a binary approach. So, we might assess whether solutions meet each of our red-line requirements, and eliminate any unsuitable platforms outright.
By the end of this step, we should have a clear picture of two things:
- Whether any suitable solutions are on the market.
- If so, how we can compare the suitability of our various options.
3. Assess internal development resources
If we’re deciding whether to build vs buy software, we also need to thoroughly assess our capacity to develop solutions. This can look very different across individual organizations or even departments.
In larger businesses, the question might be whether we have sufficient development resources to turn around a solution as quickly as we need it. By contrast, in an SME context, the challenge could be whether we have sufficient resources at all.
In either case, we’d need to start by translating our technical requirements into an estimate of their requisite development hours. In the first instance, this gives us a realistic picture of how large an undertaking a custom build would be.
In turn, this informs our decision-making around the likely cost and turnaround time of building a particular solution from scratch.
A thorough, robust analysis is absolutely critical here. A huge proportion of custom development projects go over time and over budget, so it’s vital that you have a realistic idea of what you’re getting into.
We’ll see how new technologies and methodologies are shifting the ground here later in this article.
For now, the goal of this step is to decide:
- If building a custom solution is a viable option.
- If so, how large an undertaking this will be.
4. Cost your options
Next, we can begin to compare and contrast our options. Assuming we’ve decided that there are equally viable options for both building and buying the solution we need, the most obvious point of comparison is their relative costs.
However, we saw earlier that comparing direct costs is problematic, as custom builds largely incur these upfront, whereas prebuilt solutions are charged on an ongoing basis.
Knowing this, along with the fact that custom solutions are generally much more expensive in the immediate term, our analysis should be focused on calculating the time horizon at which an internal build would make financial sense.
If a custom build cost us $10,000 to develop but licensing an off-the-shelf solution cost us $200 per month, they’d reach parity after a little more than four years, not accounting for additional costs, like support and maintenance.
This is well within the span of time we could reasonably expect to use a particular tool, so a custom build might be the more viable option.
However, if we expect the same solution to cost $100,000 to develop, and there’s a viable alternative out there than still costs $200 per month, this would be a harder case to make since it would take more than 40 years to break even on our development costs.
We’d therefore need a very strong business justification relating to some other aspect of the solution to build vs buy software in this scenario.
We’ll see how this balance is shifting a little bit later.
5. Factor in additional constraints
Our build vs buy decision can also be constrained by more situational factors that may entirely change your calculations. Often, these relate to internal rules, processes, and policies that govern the kinds of tools and vendors that can be used.
For example, in an enterprise context, there might be very tight requirements around vendors having specific certifications to provide tools and services.
Alternatively, internal policies relating to reviewing, vetting, and approving specific vendors and tools might be prohibitive, to the extent that the balance of costs, expediency, and convenience shifts towards custom builds.
In other cases, your build vs buy decision might be constrained by the specifics of the situation you’ve found yourself in.
For example, if your payroll software suddenly went down because it’s 20 years old and past its useful life, getting a replacement would be a pretty urgent matter. Chances are, you wouldn’t even consider building your own solution.
Instead, you’d go for the best off-the-shelf platform and get it up and running in time to pay your employees - even if it wasn’t your ideal solution. This is a situation where we wouldn’t want to sacrifice good for perfect.
You might still think about your alternatives down the line, but the point is that sometimes you need to put out fires in the immediate term.
How build vs buy decisions are changing
We’ve hinted at several points throughout this article that the ground is shifting when it comes to how businesses decide to build vs buy software. Unfortunately, this isn’t a straightforward move away from one pole and towards the other.
Instead, we can point to more fundamental changes around the way businesses build custom solutions, the way vendors bring their tools to market, and the broader economic environment that we’re all facing.
Let’s look at three key factors that are leading to a seachange in build vs buy decisions.
Methodological and operational changes
First up, we can consider how development backlogs, the global technical skills gap, and harsh economic challenges are leading businesses to seek out novel ways of building custom solutions.
There are a couple of key methodological trends that play a role here.
- Citizen development - Empowering non-developers to build custom tools, in highly specific, regulated ways.
- Rapid application development - A development methodology that focuses on iteratively building working prototypes to continuously gain user feedback and build final solutions in less time.
It’s worth noting, that each of these is limited in terms of the kinds of tools they’re suitable for.
So, citizen development is primarily applicable to relatively simple tools that relate to specific, discrete workflows, often within individual teams. The idea is to alleviate development backlogs by making it easier for everyday users to build simple solutions.
Thereby forgoing the need to engage the development team.
RAD is a great strategy for minimizing the time between ideation and deployment within custom projects, but it has somewhat limited, specific use cases. Check out our ultimate guide to rapid application development to find out more.
It’s also worth noting that both of these approaches to building solutions are contingent on furnishing your team with appropriate tools.
Low-code and no-code development
That’s where low/no-code development comes in. It’s well established that there aren’t enough skilled developers to meet global demand. However, it’s also a fact of life that internal development teams spend huge amounts of time on relatively simple tasks and projects.
Low-code platforms seek to alleviate this problem by making it faster, easier, and less labor-intensive to build the most common types of applications.
The net result is that specialist developers can ship solutions in a fraction of the time, while their non-technical colleagues can also build functional tools themselves, with little or no coding skills.
This is huge when it comes to deciding whether to build vs buy software, as low-code development completely alters the picture in terms of the time and resources needed to create custom solutions.
We’ll see how Budibase is at the forefront of this revolution in a few minutes.
Integrations and workflow automation tools
And finally, we have dedicated integration and workflow management tools. For example, Zapier. In some ways, these don’t quite fit into the build vs buy dichotomy. Rather, the idea is to enable you to do more with your existing tools.
The basic goal is to empower you to define simple automation rules across different nodes in your software stack.
So, an event in one platform might trigger an action in another.
Therefore, you can sometimes avoid the need for entirely new platforms, by deriving more value from the tools you have already.
This is still dependent on a couple of key things. First, it’s only a viable option in cases where the tools we want to leverage actually support these kinds of platforms.
Second, we may well still encounter many of the issues we saw for both building and buying solutions - although to varying degrees.
So, this isn’t exactly a silver bullet, so much a helpful halfway house between building and buying solutions.
Build better solutions, faster with Budibase
At Budibase, we’re proud to lead the charge in the low-code revolution. Our mission is to transform the way businesses build tools, forever.
We think Budibase is the smart solution for busy IT teams. Here’s why tens of thousands of businesses around the world agree.
Simple by default
Budibase is simple by default, but extensible when you need it to be. With our open-source, low-code platform , you can build fully deployable, custom applications, in as little as five minutes.
Check out our product overview to find out more.
Leverage existing data
Connect to the data you need, with minimal custom code. Budibase offers dedicated connection UIs for MySQL, MSSQL, Postgres, REST, S3, Airtable, Mongo, Couch, Oracle, Elasticsearch, and more.
Or, we have our own internal database, with full support for CSV uploads. Simply add your data, and Budibase will autogenerate a working CRUD app , in just a few clicks.
Hosting and deployment
Budibase is the smart choice for IT teams that need low-code tools they can host anywhere. Deploy to your own infrastructure using Kubernetes, Docker, Digital Ocean, and more for complete control over your solutions.
Or, if you need to get up and running quickly, we also offer our own cloud hosting platform. Check out our pricing page to find out more about both options.
Build custom plug-ins to expand on Budibase’s core functionality. Use our CLI tools to build your own data sources and components, to use across all of your Budibase builds. No other low-code platform offers so much extensibility.
Take a look at our plug-ins documentation to learn more.
Role-based access control is the ideal solution to manage permissions and limit data exposure, without sacrificing usability. With Budibase, you can easily grant and restrict access at the level of data sources, queries, screens, or individual components.
Check out our in-depth guide on how to implement RBAC .
Use Budibase to automate workflows, with minimal custom code. Trigger, nest, and combine our built-in library of automation actions to create your own custom flows and rules. Build external events, triggers, and actions into your automations, with Zapier and WebHooks.
To find out more, take a look at our ultimate guide to workflow automation .
50+ free app templates
Obviously, we’re biased, but we think Budibase is the smart way to build custom solutions. Our platform is designed to empower users to build tools in minutes, not months. But don’t just take our word for it.
We’ve created over 50 fully deployable, customizable, free app templates to show what our platform can do.
To start building apps the fast, cost-effective way, sign up to Budibase today for free.