To build or not to build? For any business looking to scale up, that is the question. When a company moves beyond the capacity of consumer software, choosing between enterprise-level point solutions and holistic custom software becomes necessary.
Enterprise software can be overly-complicated and cumbersome for smaller businesses, requiring hours of training for employees who use it. But building software from scratch can seem equally daunting. Full-time employees with the chops to do it are expensive and sometimes hard to find, and often there just isn’t time for development cycles.
Think of it like building a house—you can buy a pre-built home and add onto it, but you might not be able to match paint, materials, and style. Or maybe you hire an architect to build your home, but it takes a couple of years and a whole lot of money. Or maybe you build it in a completely new way, with 3D printed materials. Either way has upsides and downsides to it.
There are three major considerations for anyone looking to make the jump to industrial-grade software: time, cost, and maintenance. There are a lot of factors at play for each of these areas, and some of them are fairly subtle, unexpected, and interconnected. That’s why we’re here to help you parse the details and figure out what the best approach is for you.
Point Solutions—What’s the Point?
Point solutions are the bread and butter of the SaaS (Software as a Service) industry. These are typically cloud-based services that usually don’t even require an installation process before they can get up and running. You just pay the company, usually on a per-user scale, get everyone signed up, and boom—you can start using it right away.
The reason they’re called “point solutions” is because they fulfill a very specific niche. One may be a chat app, another is a CRM, and yet another is your enterprise email client. There are point solutions for just about every generalized need you might have, and most of them have at least some small degree of customizability.
However, there are downsides, and they aren’t always apparent at first.
There are over 10000 SaaS companies, according to 99Firms research, each one providing different software options. Some of them do one thing, some do many, and some don’t do much of anything at all. The quality of service, user-friendliness, and capacities of each service can vary wildly. Individually, they may not be expensive, but if you are trying to construct a functional system for your entire company, you’ll run into issues with compatibility, redundancies, and cost. Even just determining which software to use can be a labyrinthine experience, and the more robust a software is, the more training users will need, increasing time and costs..
For example, some organizations use G-Suite services, which have a chat app, comments sections for spreadsheet and word processing, and email. So when paying for enterprise level G-Suite, it would seem silly to also pay for Slack, a service that provides chat functions exclusively, right?
And yet, this happens all the time. In fact, according to a 2015 IATAM study, companies on average had $259 of unused, redundant software on each computer at their organization. In the US alone, that came out to $30B per year wasted. Back in 2015, Enterprise software spending was about $320B. Today that number is $506B according to Statista.
Single-duty software can be great if there’s a gap in your workflow and you know exactly what you want, particularly if you’re a tight, lean organization with the cash flow to afford it. Just make sure before you look before you leap into it, otherwise you might find it difficult to migrate to another system as you continue to grow.
Software as a Suit—Bespoke
Building bespoke software comes in two flavors: traditional, and low/no-code. Typically, traditional software development involving a development team provides a level of customization and optimization that is unavailable anywhere else. The only restrictions involved are the amount of resources you have to commit, and the technical limitations of cutting-edge hard/software (even Elon Musk can’t create true holograms). On the other hand, this method of development is prohibitively resource-intensive for all but the largest or most specialized of companies. Between bringing development personnel on board, planning the build process, iterating upon the software, and implementing it effectively, traditional software development can easily become a years-long process that requires regular maintenance by specialists and constant security audits.
According to Soltech, custom enterprise software can cost anywhere from $75,000 to $750,000 to design, build, and implement. That’s an enormous cost to bear for most SMBs. Comparatively, no/low-code systems can save a business enormous amounts of money when used to replace disparate point solutions.
Once a company determines that they want software built to their specifications without the resource strain of traditional development, the question is not whether to build, but how. Many of these companies are turning to no/low-code platforms that offer powerful solutions in a simple package, at a lower cost than myriad point solutions or traditional software development.
In essence, no/low-code development tools provide users with a simple interface where they can mix and match stock app functions, manipulating them to create a variety of custom software in one centralized place. There are a number of advantages that no/low-code platforms offer to organizations who are looking for a long-term, flexible solution to their problems—they’re simple to build with, integrated, and easy to maintain.
Simplicity
Most low/no-code platforms offer drag-and-drop functionality, letting you tailor features and processes to fit your vision. Because no-code platforms rely on code-free interfaces to build, design, and launch custom software, they have a much easier learning curve. With a straightforward, intuitive interface, just about any team member is able to experiment, iterate, and implement software applications in a short period of time.
Start small, build an app with a simple function such as converting spreadsheets or setting up a CRM, and you’ll find yourself whipping up apps to solve just about any problem in no time.
Integration
When you use the same platform to build many kinds of software, you’re also able to increase their potential utility, navigate across them more easily, and generally simplify your workflows. By keeping everything on one platform, no/low-code app builders sidestep one of the largest problems with point solutions—integration. When you have ten programs that all need to communicate with each other, there is a lot of copy-pasting and file formatting involved, not to mention API nightmares such as asymmetrical updates, incompatibility, and forced interfaces (e.g., can’t use a program integration on Firefox, so you have to use MS Edge). This creates opportunities for errors to occur. Whether it's lost data or even just typos, these kinds of errors can cost your business a lot of time and money.
When you build apps on a single platform, they do exactly what you want them to, because the platform lets the apps communicate with each other. That means when you need to import a spreadsheet and turn it into a CRM or accounting record, that record’s integrity is maintained across the system.
Maintenance
Software updates are an inescapable part of cloud computing. Maintaining security, introducing new features, and fixing bugs are just a few of the reasons for regular updates. This can be a problem when using multiple single-duty software solutions at once. Sometimes they may become incompatible with each other, switch their file formatting standards, or just introduce strange bugs into a system.
When you go with traditional software, the maintenance process looks a lot like this:
-
-
- You discover a problem
- You email the developer about it
- They email back asking for more information
- They implement a possible fix
- You test it
- Either it works, or you go back to step 2.
-
At every step of that process, you’re going back and forth between a third-party, and there are any number of ways which that process can frustrate everyone involved.
With integrated software, everything is updated with compatibility in mind, so you’ll never have to worry about finding out that your various software have stopped playing nice, which can result in some catastrophic horror stories.
Additionally, because the software building process is less esoteric on a no-code platform, anyone can learn how to improve and iterate upon the apps you’re using, and even build their own new ones. With more input and ideas available, upkeep and maintenance has a much larger pool of talent to draw from, spreading the burden of updates away from overworked dev teams.
Okay, So What Should I Go With?
Now that we’ve touched upon all of the different options, which one is right for you?
Here’s your answer:
- Traditional software development: Extremely customizable, very powerful, most potential for optimization
- Point solution: Potentially fastest implementation, Great for specific use cases, least likely to require training
- No/low code software platforms: Democratized software building, most efficient functionality/cost ratio, quickest way to custom software, most potential for integration
Sure, this is a bit of an oversimplification, but you get the idea. If you still aren’t sure about whether or not low/no-code is right for you, check out our eBook, We’re All Software Developers Now, and dig into the finer points, statistics, and stories of people who have made no/low code work wonders for them.
Read Next:
About the Author
Mark is an avid writer with a ton of experience in journalism, experience design, performance, and event production. He also has impeccable taste in music. He currently lives and works as a writer/editor in the SF Bay Area. When he's not working, he's probably either spinning records or scoring goals on a bike polo court near you.
