What is low code? Definition, use cases, and benefits

On the one hand, it’s clear low code has market traction: in April 2021, a provider of low code automation software, IPO’d at $31 billion. And Gartner predicts that by 2024, more than 65% of application development activity will come from low code application development platforms.

On the other, there is still developer skepticism: according to an Evans Data report, one in five developers never use low code. And anecdotally. And anecdotally, many developers express a similar sentiment:

Our thesis? Although low code may not be disrupting or replacing software development, it is definitely transforming it.

To that effect, we thought it’d be helpful to offer an overview of the low code landscape. We’ll dig into the basics, the controversies, and what we think the future holds. We’ll answer questions such as:

This article is most useful for non-developers, but anyone interested in a primer is welcome.

Low code is the development of software via a visual drag-and-drop interface. The logic is simple and the UI is intuitive; ideally, it offers possibilities for customizing the majority of components with code, but the idea is that most of the work can be done without spending time on writing custom code.

A low code development platform consists of three major components.

2. Connectors: Depending on the low code platform, various kinds of connectors plug the platform into a variety of back-end services, databases, and APIs. These provide extensibility and increased functionality. Developers tend to prioritize connectors because the usefulness of a low code platform is directly tied to what it integrates with. Some early low code platforms are short on connection functionality, leaving developers with with unnecessary workarounds or missed requirements.

3. Application lifecycle manager: If a low-code platform promises robust results that match those produced by coding, then it needs to come with quality lifecycle management: tools for debugging, deployment, and maintenance of code across testing, staging, and production (necessary steps for building any app, no matter how you build it).

The primary goal of low code is to reduce the amount of “hand-coding” (i.e., code done from scratch) and increase the amount of code reused and apps developed. Low code is highly composable, meaning that when you use the visual IDE to construct a component, it’s easy to then reuse that component in different situations.
The reason why it’s called “low code” (as opposed to “no code,” which we’ll get into in the next section) is that low code development is split roughly 80:20 between visual coding and hand-coding. You build about 80% of your app using a low code UI, then hand-code the rest—usually last-mile specifications, as necessary.

In the below video, for instance, our developer advocate, Chris Smith, creates an internal tool app for managing sales inventory stored in MongoDB: a vast majority using Retool’s visual interface, then final customizations using in-line JavaScript.

Let’s bust a myth right from the get-go: low code and no code are not the same thing. At a fundamental level, the technologies are different.

If low code is the minimization of hand-coding, then no code is the elimination of hand-coding.

No code also uses a visual workflow builder and IDE, but it doesn’t require—or, even more importantly—allow developers to hand-code at all. This is the fundamental difference between the two types of technologies, and here is why.

If these were the only differences, you could imagine low code and no code some day converging or a vendor offering a platform that effectively does both. This ignores the fact, however, that low code and no code are different at a fundamental level.

No code abstracts away code entirely, whereas low code retains the ability to code. The ramifications are profound.

Low code is a natural extension of web frameworks, component libraries, and the long tradition of borrowing pre-built work and adding nuances that are unique to each product, industry, or use case. Developers have always strived for more composability, and entire businesses have been built on this desire: think API-first companies like Twilio and package managers like npm.

In that regard, low code is more a continuation of this tradition: it helps developers move faster, but respects the fact that developers will still need to customize.

No code aims at a new audience with a new proposal: turn all of the code into UIs, logic, and simple steps, such that non-technical business users (or “citizen developers”) can now “code.”

As such, no code, by its very nature, is opinionated and inflexible.

The ability to customize code is a DNA-level difference, and it has ripple effects.

Low code use cases range from the complex (such as full-on app development) to the relatively simple (such as landing page design).

Internal tools aren’t flashy, but developers spend a lot of time working on them: according to our The state of internal tools in 2021 survey, developers spend nearly a third of their time (30%) building internal applications. This is not ideal: while internal tools are profoundly impactful, it is not necessarily how developers or their orgs want to spend their time.

With low code platforms, developers can build internal tools faster, enable some non-developers to build them, too, democratize data across the organization, and protect their stack from “shadow IT” that inevitably creeps in when developers can’t fulfill al internal tool requests timely.

A lot of the low code platforms let you build an intuitive user interface from drag-and-drop components. This is especially useful for back-end developers who may have to build dashboards but aren’t familiar with the nuances of front-end languages and frameworks, or UX best practices.

This use case bleeds into others on the list. A popular internal tool, for instance, is a sales dashboard that helps sales reps track deal flow. The sales team might ask a back-end developer to make such a tool, and while the back-end developer can easily handle the data, they might not be able to present that data in an intuitive way.

With low code, a back-end developer can easily spin up a UI that they can layer onto the data they retrieve.

Platforms like UiPath, Workato, and Appian provide ways to integrate apps and automate the processes that flow between them.

Many companies, large enterprises especially, are stuck with legacy infrastructure (think SAP, Oracle, Citrix) that they can’t afford to rip out and replace. These companies, however, are increasingly feeling the heat from nimble startups relying on custom-built tools, SaaS apps, and APIs.

With low code, enterprises can achieve some of that startup speed by connecting and automating the legacy systems. Enterprises can then adjust and iterate much like startups can, leaving them less vulnerable to disruption.

Low code tools like Bubble.io enable non-developers to spin up entire web apps, and tools like Memberful enable non-developers to add specific features to their apps (in Memberful’s case, membership).

Some of the results of Bubble.io, according to their showcase page, include:

This use case is one where the difference between low code and no code really matters. Be aware of the customization limitations of no code as your app scales.

The minimum viable product (MVP) methodology, originating with famed startup expert Eric Ries, asks developers and startups to ship products faster, get feedback earlier, and build with customers in mind. MVPs (and prototypes, a similar idea) are a great use case for low code.

The idea is this: don’t invest tons of development resources into an app or feature you’re unsure of. When you’re building an app from scratch, the necessary up-front investment is immense. You have to think about hosting, the back-end, the front-end, the UI, maintenance, monitoring analytics… the list goes on.

Those are all distractions from what your primary focus needs to be at this early stage: your user and what they need, aka the product-market fit. With low code, you can get most of the way toward your final product, test it with your customers, and then, and only then, make an investment you’re confident in.

Low code has a variety of benefits and drawbacks, all of which depend on which low code platform(s) you choose and how you use it.

Though low code comes with many benefits, they generally come down to three core ones.

Compared to hand-coding, low code development gets developers from idea to execution to production much faster.

According to Kintone research, developers using low code tools “turn around their required applications in a matter of weeks, or a couple of months. Only 17% report turnaround times exceeding three months.”

Many low code platforms come with pre-built components, and most come with the ability to make components developers can reuse, making low code development eminently composable. Improved productivity and efficiency is backed up by research, both in terms of sheer speed and the ability to meet previously unmet demand:

Developers are in short supply.

Demand for software developers is already outpacing supply: TechRepublic research found that 83% of CIOs struggle to find tech talent.

Low code allows developers to move faster and do more, but it also allows non-developers, such as operations staff, to take part in development. Companies can thus focus their development time on the most important parts of their software or product.

Perhaps the top reason developers fear low code tools is the risk of vendor lock-in. Whereas hand-coding is inherently flexible and extensible, the fear is that low code platforms have the potential to lock developers into a limited ecosystem.

This drawback varies depending on which low code platform. Legacy low code application development platforms, many of which resemble no code more than low code, can absolutely have this drawback. Modern low code platforms, however, tend to be built on the aforementioned tradition of composability, meaning that there’s an inherent respect for the need to customize.

IT might be resistant to low code adoption, and for a good reason.

IT has long had to resist the encroachment of so-called “shadow IT,” and a low code program might appear to add fuel to that fire. Imagine if employees were not only adopting SaaS tools without permission but were building apps without permission?

The problem, however, is less with low code itself and more with how companies implement and scale low code programs. Eventually, governance becomes necessary.

And larger IT departments will have to stay nimble with low code:

According to Jason Bloomberg, an IT industry analyst, “IT has been telling business stakeholders for years that the six month/million dollar plan is the only way to build enterprise software,” but now, according to Simon Chan, Founder and CEO of DigiVue Consulting, “the same systems can be implemented by smaller players at a fraction of the price and in a fraction of the time,” which “has leveled the playing field.”

Some developers have an instinctual resistance to low code platforms based on the assumption that any code that isn’t hand-written can’t be robust enough to scale. This assumption isn’t true—low code apps can scale to enterprise proportions—but the nugget of truth is that many low code platforms aren’t built with scale in mind.

OutSystems, for instance, in a surprising moment of vendor honesty, notes that “When it’s time to scale, integrate with existing systems, or perform under extreme conditions like a mobile banking app on Black Friday, the [low code] application could buckle under the weight of functional and nonfunctional requirements. If an application built with low-code needs updating or if the underlying technology needs changing, good luck.”The solution here tends to be picking a low code platform that can develop apps that can scale. And scalability tends to come from leaning into low code’s advantages. No code apps are much more likely to suffer from scalability problems because they aren’t customized

Low code development will not replace traditional software development. Full stop. But it will change software development—and in some areas, the change will be dramatic.

Low code, understood historically, is another layer of abstraction between the developer and the code.

While the term “low code” may be relatively (the first popular instance of the phrase occurred in a 2014 Forrester report) we can trace low code back through the history of code.

The history of code is itself a history of abstraction: every programming language is a more human-readable version of binary code. What’s unreadable to us now, like FORTRAN, was a big step toward readability back in the day. As Nacho Iacovino, developer advocate at Clerk, wrote in a guest post for us, even modern options like React are “a low(er)-code option, compared with the alternative of vanilla JavaScript which would take many more lines of code to achieve the same results.”

In the same way, low code is another step toward readability and up the ladder of abstraction. Viewed this way, low code isn’t a departure from history so much as it is a continuation.

One of the reasons developers are skeptical of low code is the hype that is often not accompanied by practical use cases and real-world usefulness of low code software. We agree that low code won’t disrupt, displace, or destroy software development. Instead, developers will try particular low code tools, especially ones specialized for specific use cases, and replace hand-coding development when it benefits them to do so.

Internal tool development (which developers spend 30% of their time doing) is an ideal use for low code. Though two out of three developers default to building from scratch (instead of using a spreadsheet or a SaaS tool), 88% of developers that do build internal apps using low code plan to keep building that way in the future. In other words, most developers have a need that low code solves for but aren’t using low code—but once they try low code, they keep using it.

Scott Brinker, VP of Platform Ecosystem at HubSpot, thinks that the best way to think of low code is to think of it as a way to expand the circle of people who can develop software.

Power users are becoming more powerful, so powerful that they can now develop software. John Rymer, an analyst at Forrester, can “see maybe 100 million people—business people—engaged in producing software.”

Searches for “low-code app development platform” on Google Trends

That means that companies don’t need to hire software developers for the vast majority of software needs. It doesn’t mean that developer hiring will slow, but that companies can reallocate developer hiring away from projects like internal tool development toward customer-facing features, as well as complex and innovative software development problems.

Often lost in the discussion of low code and its effects is context: low code looks very different to startups and enterprises.

Startups are time- and resource-strapped, which is the primary reason they adopt low code tools. With low code, their engineers can move faster and make a greater impact in three primary ways:

For startups, who may only have a couple of developers, this time and effort savings is precious.

With low code, back-end developers can create pretty, intuitive apps and tools.

As we covered above, low code enables companies to rapidly build MVPs and prototypes. This is especially useful for startups, who may still be settling on a product and pursuing product-market fit. The right low code tool will also enable rapid iteration, such that startups can debut and improve products before dedicating much to custom coding an app that will fall flat on its face.

Enterprises are not in want of resources as much as startups are, but they are often stuck with technical debt,driven by prior investments in legacy technologies. This encouraging many enterprises to adopt low code and pursue modernization. There are three primary use cases for enterprises and low code.

Enterprise technology stacks are often overly complex, old, and slow. Low code automation tools can reduce the negative effects of that complexity by automating the steps involved in the processes the legacy tools run.

Software robots, offered by low code RPA tools, for instance, can run unattended, meaning they can operate in the background, 24/7, handling all the agonizingly manual processes legacy tools typically require

With low code, enterprises can modernize their legacy technology stacks without ripping them out and replacing them.

Enterprises are not only stuck with legacy technology; those legacy technologies are themselves often stuck in disparate silos. Connecting your ERPs to your CRMs and back again, for instance, can be a nightmare. Enterprises often face the choice of either living with it and being inefficient, or hiring armies of consultants to fix it all, which is expensive.

Low code tools can layer on top of these tools and create a much more usable, intuitive interface. Business users can then access and use systems they previously would have had to request help from developers to use.

For enterprises, digital transformation is a serious pursuit as much as a buzzword. Many enterprises are still operating on paper or so-called “digital paper” systems — technologies that weren’t designed with the internet and native digital capabilities in mind.In clinical research, for example, as product manager Stephanie Morillo points out,many organizations still use Excel rather than use a modern database tool.

If ever there was a need for low code, this is it.

Hot take thought leadership on low code often relies on the phrase “the future of,” as if software development—an already complex and diverse field of technologies and methodologies—will somehow evolve into one monolithic thing.

Developers have had plenty of reasons to be skeptical of the hype. Many have seen the rise of technology fads that similarly promised the reduction—or even the elimination—of traditional programming. The elders among us will remember Visual Basic and PowerBuilder.

However, we’re reaching an inflection point where the capabilities of low code technologies are actually ready to meet their promised potential. And, as modern low code platforms enable developers to choose when and where they want to spend time coding, the industry may shift in big, unpredictable ways.

Our latest research shows that 89% of developers enjoy building with low code, 90% of them believe low code meets their needs, and 89% plan to keep building with low code. And, as we mentioned at the top of this article, Gartner predicts that more than 65% of application development activity will come from low code application development platforms by 2024.

Companies, analysts, and developers agree: low code is here to stay. Armed with low code, developers can put a laser sharp focus on the most important software development problems.

The effect of this reallocation is hard to understate.