The days of companies purchasing commercial off-the-shelf (COTS) software fully knowing and accepting the fact that they will need to either accept its limitations, or undertake a major customization effort, are long-gone. Companies can’t afford to constrain the way they operate or the way that employees work. For those reasons and others, more businesses are turning to low-code.

The tide has been turning away from off-the-shelf software for many decades, although the trend has accelerated in recent years.

For example, many COTS vendors have offered customization as an option, albeit for a hefty sum. The customization is necessary in some cases because the application doesn’t meet the customer’s requirements as-is. In short, one-size does not fit all.

Luckily for software customers, the software-as-a-service (SaaS) movement emerged, and it has helped customers right-size COTS a bit. In fact, let’s call these vendors “COTS-SaaS,” because while they may sell software as a service you can use via the cloud, their service-product still has many of the same issues on-prem COTS software has.

To seem more “custom,” these enterprise COTS-SaaS vendors began breaking their monolithic applications down into smaller SaaS suites out of necessity because that’s the way the software industry was headed. The selling point was “customer choice” because customers could select whatever modules they needed SaaS suites also tend to come with the added assurance that if other modules are adopted in the future, everything will be interoperable, except perhaps recently acquired products.

Meanwhile, more software vendors added a professional services arm to their business models, much like the world’s largest software companies. These new service entities handle customizations, installations, product training, problem-solving related within the scope of the vendor’s products, etc. However, the service arms aren’t completely altruistic because they’re designed to increase sales and reliance on the COTS vendor.

Now, with rampant digital disruption, COTS alone is a risky proposition because organizations can’t afford to limit their operational capabilities to whatever the COTS software provides. In addition, COTS customization takes time, which businesses don’t have, competitively speaking.

When the rules of business competitiveness change, organizations must be able to adapt. Doing that with COTS alone just isn’t practical.

Disruption Is Fueling Low-Code

Some organizations are replacing COTS with low-code because it gives them the freedom to create applications that directly align with their business objectives from the start. A smaller subset uses OutSystems to build core and mission-critical systems, which in turn gives them the flexibility to build exactly what they want for internal and external customers.

For example, electricity generation and distribution company EDP Brasil controls the amount of energy it generates using an application built by OutSystems implementation partner MindSource Brasil. William Durante, a representative from MindSource Brasil, told me at the OutSystems NextStep event in Denver last September, that it would have taken 10 months to customize EDP Brasil’s COTS application. Building the core, mission-critical application from scratch using OutSystems took 13 months and cost less.

Other organizations are innovating around and on top of their mission-critical legacy systems. An example of that is employee benefits, HR and payroll administration company bSwift. bSwift wanted to provide every customer with a customized portal option, not just its largest customers. However, mass customization can be too costly to be practical.

“When we’re in the sales cycle, we can tell those new prospects, ‘Yes, we can deliver this custom, total compensation portal, for you. Yes, we can deliver this custom integration with your Workday platform. OutSystems allowed us to create a completely different organization, a completely different way of doing business from a product development perspective.”

Devin Parsons, vice president of digital transformation at bSwift.

I wouldn’t recommend building core or mission-critical applications using just any low-code or no-code platform, however, because not all of them are enterprise-grade platforms. Core and mission-critical systems require extremely high system availability, security, access controls, governance, and quite often, regulatory compliance, which many platforms are not robust enough to support.

Low-Code Is Becoming a Necessity

There’s also a societal element that’s driving the need for low-code, which is the high expectations of today’s software users. Employees and customers don’t want to adapt their behavior to software. They expect software to adapt to their needs and desires.

This trend is evident in the expanded settings controls of modern desktop, web, and mobile COTS applications. It’s also evident in the behavior of software application teams that continuously monitor application usage and user feedback.

Interestingly, user expectations are not set solely by the applications in a specific vertical. While it’s true that Amazon sets a high bar for the retail industry to follow, any application or website with a search capability is expected to behave like Google. The industry or use case is irrelevant in that case.

Similarly, Hotels.com added a “guest checkout” option to its website well over a decade ago. The change was a simple one, involving just a few lines of code. The change was a smashing success because some customers just want to book a room quickly, not spend several minutes creating yet another customer account and password. Now, all kinds of ecommerce sites provide a guest checkout option.

Low-code provides a way for organizations to be more nimble than they’ve ever been, which makes disruption a lot less painful and innovation a lot easier to facilitate.

Low-Code Should Satisfy All Enterprise Requirements

COTS was originally sold to IT, but more recently there’s been a bifurcation of what must be sold to IT and what can be sold to lines of business. If it’s a marketing application, marketing decision-makers are the target. Moreover, it’s easy to sell SaaS software to lines of business because one does not need all kinds of approvals; one can simply sign up and input a credit card number. However, as with most COTS solutions, all SaaS roads, at least from a user perspective, lead back to IT. If the application doesn’t work as expected, call IT. If it only kinda works, call IT. If governance becomes an issue, IT, risk management, and compliance may get involved.

One of the reasons brand-name companies choose OutSystems is because the platform is enterprise-grade. It has all of the controls enterprises expect and the capabilities software developers expect. If a someone in a line of business builds an application that exceeds her capabilities, or she doesn’t have time to maintain it, the application can be handed over to a professional developer as-is for continued evolution. The developer doesn’t have to rewrite the application from scratch.

With OutSystems, organizations have the freedom to innovate, and the enterprise-class controls they need to manage potential risks. In fact, flexibility and safety are two just reasons why many organizations are standardizing on OutSystems.

Bottom Line

COTS isn’t dead and it’s not going to die anytime soon because many businesses are locked into software patterns that can be difficult to change. Low-code, at least the way OutSystems enables it, allows these businesses and others to replace and enhance COTS safely.

Meanwhile, disruption is a fact of today’s dynamic business environment and no organization is immune. The key question for the disrupted is what will they do about it? Industry leaders across industries and around the globe choose OutSystems.

Want to learn more about OutSystems low-code development? Schedule a demo with someone from our team.