Almost every organization has a need for document management; in some cases, this need is met by Sharepoint or Google Drive, and in other cases, an enterprise document management system is the chosen solution. Buying off-the-shelf of software-as-a-service products makes sense for many businesses, especially when that software can solve a problem and allow your organization to focus on more important workstreams.
The Pros of Buying a software solution are well-documented:
But the Cons of Buying can sometimes get in the way:
Buying is the far more common choice; most organizations will use things like accounting software, a recruiting product, or a sales development tool to enable their day-to-day operations, and it wouldn't make sense to build these yourself. So instead of Buy vs. Build or Build vs. Buy, the decision might be better framed as figuring out when you shouldn't buy a solution.
In some situations, those Cons of Buying may seem like too much to accept. That's when you run into that other tempting choice: to build your software yourself. But you should not make that choice lightly; you need to value your time and resources enough to only build when you absolutely need to.
In cases where the software is tied to your company’s core competencies, when you have requirements for customization or integration that aren’t easily met by a vendor, or when you’ve outgrown the off-the-shelf products that are available, this option may seem far more viable than trying to buy. In some cases, the software is the business, and the features you need to build are a key part of what you are providing to your customers. It may not be feasible to do anything other than build it yourself.
But building isn’t easy, and it requires a great deal of planning. Not only are there architectural diagrams, user stories or feature checklists, and the project onboarding of the developers who will write the code, there is also the project management, the product ownership, the infrastructure roll-out, and the processes and teams required for testing, maintenance, and user support.
All of these considerations need to be included in your plan.
In the case of document management, as with many other types of software, there will be many points of integration between the core functionality and other components, whether new or existing, to handle tasks such as the import, processing, and retrieval of documents.
The idea of trying to integrate with an off-the-shelf solution may be a non-starter in such situations, whether that’s due to time, cost, control, complexity, or in many cases, a combination of all four.
Building allows your organization to better control the outcome, assuming that your organization has the resources and knowledge to succeed.
The Pros of Building showcase the potential of custom software:
But the Cons of Building often come with more risk than the Cons of Buying:
So even if the Cons of Buying are worrisome, these Cons of Building should give any organization pause. In the case of document management, these Cons of Building may seem enough to kill the idea completely.
The expectation for most document management systems is that the number of documents will grow year over year, with the corresponding increases in storage costs and performance requirements. There is a very real risk that a custom-built document management system will run into limits when processing or retrieving documents, not just due to the growing numbers, but also due to possible limitations with how the metadata and storage were originally designed.
One of the largest penalties to productivity is found in waiting time wastage, when your workers and even your other systems are left to wait while an overtaxed application struggles to perform tasks that may have run seamlessly before. A well-architected system can reduce or even prevent this waiting time wastage, but designing and implementing such a system is not easy.
To reduce the risk of building custom software, while maintaining the various benefits, cloud providers like AWS and several startups (like FormKiQ) have begun to provide a new model for building custom software.
By supplying well-tested software components that are designed to provide common functionality while implementing the best practices of the cloud provider, the startups are able to cut both development time and cost for their customers, allowing them to integrate these components into their custom applications.
By supplying the corresponding source code and the infrastructure code to deploy it, these component providers ensure that not only are their customers able to integrate the components into their own cloud account, but that they are able to fully control, customize, and integrate those components.
In some cases, like FormKiQ, these components make use of serverless technology, to better handle scaling; for document management, this flexibility is a core requirement, in order to allow for any number of documents and all of the required functionality, such as storage, processing, and retrieval.
Another important difference between a software component provider like FormKiQ and more traditional Software-as-a-Service and Off-the-Shelf vendors is the ability to purchase and include only the component modules that you require; while some organizations may require enterprise features such as Antivirus Protection, Document Archival, or Single Sign-On and Federation, many companies can meet all of their requirements with less. As FormKiQ provides an Open Core version, it’s possible for many organizations to install and use the free version of our document management software. In many cases, smaller organizations may be able to run FormKiQ Core almost entirely within the AWS Free Tier.
Buying off-the-shelf or software-as-a-service is a solid option for many situations, particularly when that software is meant to support your business while your organization maintains focus on its more important tasks.
However, when dealing with your company’s core competency, or when you cannot find the right off-the-shelf or SaaS vendor solution to fit your needs, building a custom software solution is achievable, especially in situations where a vendor can provide the common components that your organization can leverage in its software development.