What is low code?
Tags: watercooler, coding
Published: 2021-06-25 22:51:54

---
canonical_url: https://retool.com/blog/what-is-low-code/
---

Low code and no code have all the hype, but among developers, they also have equal amounts of skepticism.

In March 2021, no code pioneer Zapier [acquired no-code community Makerpad](https://techcrunch.com/2021/03/08/zapier-buys-no-code-focused-makerpad-in-its-first-acquisition/). In April 2021, UiPath, a provider of low code automation software, [IPO'd at $31 billion](https://fortune.com/2021/04/21/uipath-ipo-valuation-stock-price/). Gartner predicts that by 2024, [more than 65%](https://www.forbes.com/sites/ilkerkoksal/2020/04/29/the-rise-of-low-code-app-development/) of application development activity will come from low code application development platforms.

[Software is eating the world](https://www.wsj.com/articles/SB10001424053111903480904576512250915629460), but low code and no code are making developers rethink how software is made.

Of course, (some) developers tell a different story. According to an [Evans Data report](https://evansdata.com/press/viewRelease.php?pressID=272), one in five developers never use low code, and almost three-quarters of developers use low code less than half the time. And anecdotally, many developers express a similar sentiment to low code as [Reddit user blahblahblah](https://www.reddit.com/r/learnprogramming/comments/ba82qm/should_you_learn_how_to_use_lowcode_platforms/) does below:

![reddit low-code](https://lh5.googleusercontent.com/9tY8fQgqAEbv-snvuFQZBR0kFjvh51e2KcDKhmFokrZnB6vGvGAw4dNV30A5U_3MES4RWjvi_A1i_rJE0uNYupL7wvBZduo0qTJrt2QN22WEGmaczF_v9jXlc1l5LWt9P2nPjDzW)

In this article, we're going to dig into open questions, including:

-   What is low code?
-   What's the difference between low code and no code?
-   What are the major use cases for low code?
-   What are the benefits and drawbacks of low code?
-   What does low code say about the future of software development?
-   What are some good low code development platforms?

Throughout, we'll return to the thesis that though low code may not be *disrupting* or *replacing* software development, it is *transforming* it.

What is low code? A primer
--------------------------

Low code is the development of software via a visual, drag-and-drop interface. The logic is simple and the UI is intuitive, but the results are scalable, secure, and performant.

### The three components of low code

A low code development platform consists of three major components that are, by and large, common across all low code tools and platforms.

A visual integrated development environment (IDE): This is the core of a low code development platform. It's usually a drag-and-drop interface that developers use to model workflows and declare logic. As necessary, developers can also use it to add hand-written code. Typically, developers use the IDE to create most of the app and then customize the last mile with hand-written code.

![low-code Retool](https://retool.com/blog/content/images/2021/06/Low-code.gif)

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.

Application lifecycle manager: Again, depending on the low code platform, it might also include tools for debugging, deployment, and maintenance across testing, staging, and production. If a low code platform promises robust results that match those produced by hand-coding, then it needs to come with lifecycle management to match the standard software development lifecycle that developers run when creating software from scratch.

Though low code platforms and tools can differ widely, they all tend to share these three components.

### What does low code do?

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. You get the initial speed of using an IDE and then even more speed as you reuse the resulting components.

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 visual coding to hand-coding. You build about 80% of your app using a low code UI and then hand-code the rest---usually last-mile specifications, as necessary. In the below video, for instance, our developer advocate, Chris Smith, uses in-line JavaScript to get an order total for a MongoDB admin panel.

### The future of low code is bright

Developers have plenty of reasons to be skeptical of low code. 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.

That skepticism is belied by the research. According to [Mendix research](https://www.mendix.com/resources/digital-disconnect-a-study-of-business-and-it-alignment/), 99% of organizations surveyed report that they'd benefit from the capabilities of low code platforms.

[Our own research](https://retool.com/blog/state-of-internal-tools-2021/) shows that 89% of developers enjoy building with low code, 90% of developers believe low code meets their needs, and 89% of developers plan to keep building with low code. And, as we mentioned at the top of this article, Gartner predicts that [more than 65%](https://www.forbes.com/sites/ilkerkoksal/2020/04/29/the-rise-of-low-code-app-development/) 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. We're reaching an inflection point where the capabilities of low code technology are actually ready to meet their promised potential.

Low code vs. no code: The differences and similarities
------------------------------------------------------

Let's bust a myth right from the get-go: low code and no code are *not* the same thing. They share some similarities, but on close inspection, those similarities become superficial. At a fundamental level, the technologies are different.

### What is no code?

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 developers to hand-code at all, a feature that poses both advantages and disadvantages.

At first glance, that difference seems minor. If anything, it seems advantageous for no code---why code a little when you could skip coding altogether? But it turns out that difference makes all the difference.

### Low code vs. no code: the small differences

The first differences you'll notice between low code and no code involve differences among target users, design, and UI. Though these differences aren't minor, they make low code and no code applications look slightly different.

-   Target user: Low code is for semi-technical business users and technical developers, whereas no code is just for business users. Since low code still involves some hand-coding, many low code tools still require software developers to either handle development or take it over the last mile.
-   Design: Low code platforms still depend on hard code for software architecture, whereas no code tends to have model-driven workflows and declarative logic.
-   UI: Low code provides greater flexibility, enabling developers to add hand-written code to visually developed components, whereas no code is a closed system that tends to lock users into the abilities of the no code platform in question. The ramifications of this lock-in vary depending on what platform you choose.

If these were the only differences, you could imagine low code and no code someday 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.

### Low code vs. no code: the big difference

No code abstracts away code, whereas low code retains the ability to code. Though that difference might seem small on the surface, 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 in nuances that are unique to your situation. 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.

Low code is less a disruption and more a continuation of this tradition. Low code helps developers move faster, both by helping them make decisions and follow through on actions more efficiently. That speed, however, doesn't sacrifice anything---low code respects the fact that developers will still need to customize.

The ability to customize is a DNA-level difference, and it has ripple effects. 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."

No code, by its very nature, is opinionated and inflexible. While both low code and no code manifest similarities (namely the drag-and-drop visual IDE mentioned above), they approach different problems and solve them so distinctly that the possible end results are entirely different.

5 low code use cases
--------------------

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

### 1\. Internal tools

Internal tools aren't flashy, but developers spend a lot of time working on them. According to our research in [The state of internal tools in 2021](https://retool.com/blog/state-of-internal-tools-2021/), developers spend nearly a third of their time (30%) building internal applications.

It's not that this work isn't impactful (it is; for companies with more than ten employees, one in three employees are using internal apps a developer has built). It's that internal tools aren't always how developers want to spend their time nor how businesses want to spend their development resources.

With low code platforms, you can develop internal tools faster and even enable some non-developers to build them, too.

### 2\. UI design
Some 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 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.

### 3\. Integration and automation
Platforms like [UiPath](https://www.uipath.com/), [Workato](https://www.workato.com/), and [Appian](https://appian.com/) provide ways to integrate apps and automate the processes that connect and 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 speed by connecting and automating those legacy systems. Enterprises can then adjust and iterate much like startups can, leaving them less vulnerable to disruption.

### 4\. Basic app development
Low code tools like [Bubble.io](https://bubble.io/) enable non-developers to spin up entire web apps, and low code tools like [Memberful](https://memberful.com/) 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](https://bubble.io/showcase), include:

-   [Teeming](https://www.teeming.ai/), a cloud-based tool that helps remote teams bond via interactive work sessions
-   [ResidentStreet](https://residentstreet.com/), a platform that connects people looking for "mid-term accommodations" (1-11 months) with furnished properties
-   [Incomee](https://incomee.co/), an accounting tool for freelancers

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.

### 5\. MVPs and prototypes
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. Low code helps you delay those important business decisions, so that you can make them later, when you have a stable business and customer traction.

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.

Why low code? Benefits and drawbacks
------------------------------------

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.

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

**Increase time to value (TTV)**
Compared to hand-coding, low code development gets developers from idea to execution to production much faster.

According to [Kintone research](https://resources.kintone.com/citizen-developer-business-application-report-2017), developers using low code tools "get applications out the door faster than large IT departments. They turn around their required applications in a matter of weeks, or a couple of months. Only 17% report turnaround times exceeding three months."

**Improve developer productivity and efficiency**
Many low code platforms come with pre-built components, and most come with the ability to make components you can reuse, making low code development eminently composable. Developers can borrow, build, and reuse components as they go, making them more efficient over time.

Improved productivity and efficiency is backed up by research, both in terms of sheer speed and the ability to meet previously unmet demand via improved efficiency:

-   [Forrester analyst John Rymer](https://go.forrester.com/blogs/why-you-need-to-know-about-low-code-even-if-youre-not-responsible-for-software-delivery/) says that low code platforms "have the potential to make software development as much as 10 times faster than traditional methods."
-   [Caspio research](https://go.caspio.com/state-of-custom-business-applications-2020?&_ga=2.46840167.1975902204.1623099469-1417118847.1623099469) shows that 63% of organizations using low code platforms have the skills and resources to fulfill the demand for custom apps, whereas only 41% of organizations not using low code can say the same. Similarly, 61% (as opposed to 38%) of organizations using low code typically deliver custom apps on time, on scope, and on budget.

With low code, developers can ship faster.

**Better use of existing staff**
Developers are in short supply.

According to the [Bureau of Labor Statistics](https://www.bls.gov/ooh/computer-and-information-technology/software-developers.htm#tab-6), "employment of software developers...is projected to grow 22% from 2019 to 2029, much faster than the average for all occupations." Demand for software developers is already outpacing supply, despite the ever-increasing need for software. This is backed up by [TechRepublic research](https://www.techrepublic.com/article/cio-jury-83-of-cios-struggle-to-find-tech-talent/), which found that 83% of CIOs struggle to find tech talent.

Low code allows already hired developers to move faster (as covered in the previous benefit), but it also allows non-developers, such as operations staff, to take part in development. Companies can produce more software with existing staff.

### Drawbacks
Low code isn't without its drawbacks, but you can defeat many of these by choosing a modern low code platform that fits your use case.

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

This drawback varies depending on which low code platform you choose. Legacy low code application development platforms, many of which resemble no code more than low code, can absolutely lock you into their ecosystems. 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.

Retool, for instance, is built on Javascript and SQL, meaning developers versed in those languages can easily add on to what they develop in Retool.

### Shadow IT and governance
IT might be resistant to low code adoption.

According to [Jason Bloomberg](https://www.forbes.com/sites/jasonbloomberg/2017/07/20/the-low-codeno-code-movement-more-disruptive-than-you-realize/?sh=4db92168722a), 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](https://www.forbes.com/sites/jasonbloomberg/2017/07/20/the-low-codeno-code-movement-more-disruptive-than-you-realize/?sh=4db92168722a), 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."

What might appear to be a level playing field to a business user, however, can appear to be a threat to IT. 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, the IT admin might fear, if employees were not only adopting SaaS tools without permission but were *building* apps without permission?

This isn't IT being controlling. There are serious ramifications, especially in terms of security, from letting more people build software. And they're not wrong --- according to [Kintone research](https://resources.kintone.com/citizen-developer-business-application-report-2017), more than one in four surveyed organizations have no citizen development policy of any kind in place. The problem is less with low code itself and more with how companies implement and scale low code programs. Eventually, governance becomes necessary.

### Scalability
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](https://www.outsystems.com/blog/posts/what-is-low-code/), 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. Use low code to build your foundation but hand-code your way to scalability.

How low code will shape the future of software development
----------------------------------------------------------

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 will add (more) abstraction
Low code, understood historically, is another layer of abstraction between developer and code.

You can trace the roots of low code back to the [fourth-generation programming languages](https://www.techopedia.com/definition/24308/fourth-generation-programming-language-4gl) (think Visual Basic and PowerBuilder) and computer-aided software engineering (CASE), rapid application development (RAD), and business process management (BPM) tools from the 1990s. These early tools and platforms tried to fulfill the same promise modern low code does: build real apps in less time and with less code.

It took another couple of decades for the brand name to form, however. The first popular instance of the phrase "low code" occurred in a [2014 Forrester report](https://www.forrester.com/report/New+Development+Platforms+Emerge+For+CustomerFacing+Applications/-/E-RES113411) and has been on a steady rise since.

![google trends low code](https://lh6.googleusercontent.com/wK6K8ADGrKPs6bWBlDUaxJvIOLSJFrmXpTGmUlJlEShboZzgpvZgbF1Cj5Sk-iIV2NgFEtBZO-0vDQ_IhAp1cYKBBAPt2FSEJ6oJz0-mA0R22C1UstsVY-VrrbJQF8_-H1n__zqN)

*Searches for "low-code app development platform" on Google Trends*

If you want to get technical, you can trace low code back through the history of code, too. 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](https://retool.com/blog/nacho-iacovino-on-the-future-of-internal-tools/) 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.

### Low code will add, not disrupt
A major reason developers are skeptical of low code is the hype. A simple Google search reveals the scale of the hype. "Is low code the future" returns over 2 million results, and articles on the topic include titles like:

-   Why Low-Code Automation Is The Tech Of The Future
-   Why low-code and no-code are the future of enterprise applications
-   The Future of Software is No Code and Low Code Programming
-   Low Code Is The Future Of Application Development
-   Low-code programming -- the next frontier in app development

![low-code collage](https://retool.com/blog/content/images/2021/06/Low-collage.png)

Realistically, low code isn't *the* future; it's part of the future. Internal tool development, our specialty, provides a perfect example.

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](https://retool.com/blog/state-of-internal-tools-2021/) (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.

More than likely, 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.

### Low code will expand the circle of software development
According to [Scott Brinker, VP of Platform Ecosystem at HubSpot](https://chiefmartec.com/2021/03/marketing-superpowers-ai-code-transform-every-marketer-maker/), 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.

Low code, as well as no code, enables more people to build software. This bears out in the research so far. According to [Kintone research](https://resources.kintone.com/citizen-developer-business-application-report-2017), many non-IT low code developers are power users "embedded within line-of-business departments building the applications."

Power users are becoming more powerful, so powerful that they can now develop software. According to [John Rymer, an analyst at Forrester](https://searchsoftwarequality.techtarget.com/news/252469924/Low-code-goes-mainstream-to-ease-app-dev-woes), he can "see maybe 100 million people---business people---engaged in producing software."

![](https://retool.com/blog/content/images/2021/06/Low-code.svg)

That means that companies don't need to hire software developers for every software need. That doesn't mean that developer hiring will slow, but that companies can reallocate developer hiring away from some projects (say, internal tool development) and toward customer-facing features as well as complex and unique software development problems.

The impact of low code on startups and enterprises
--------------------------------------------------

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

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

**Internal tools will be easier to make**
With low code tools, developers can re-focus from internal tool development toward customer-facing features. For startups, who may only have a couple of developers, this time and effort are precious. With product-market fit still on the horizon, early-stage startups need as many engineering resources as possible dedicated to iteration.

**Back-end developers will be able to develop better services**
Back-end developers are well-versed in systems and functionality but not in UX design. With low code, even back-end developers can create pretty, intuitive apps and tools. The ever-elusive 10x full-stack developer becomes more attainable if you can enable back-end developers to create things only a front-end developer would normally be able to make.

**Validation will come sooner in a startup's life**
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 in the way of hand-coding.

Curtis Cummings, a Senior Software Engineer at On Deck, said in an [interview he did with Retool](https://retool.com/blog/new-developments-curtis-cummings-on-deck/), "I've been on a couple of different projects in my consulting career where we had this perfect spec, we built it perfectly to spec, went out to users and it fell flat on its face because all the assumptions that backed up that spec weren't validated or grounded in user data."

With low code, startups are less likely to fall on their faces.

### Low code and enterprises
Enterprises are not, generally, in want of resources like startups are, but they are often stuck with technical debt.

Enterprise technical debt, driven by prior investments in now legacy technologies, is encouraging many enterprises to adopt low code and pursue modernization. There are three primary use cases for enterprises and low code.

**Improved agility**
Low code tools, especially those from the RPA and workflow automation fields, will enable enterprises to move more nimbly. Enterprise technology stacks are often overly complex, old, and slow. Low code automation tools can reduce the negative effects of that complexity. These tools can automate the steps involved in the processes these legacy tools run.

Software robots, offered by low code RPA tools, for instance, can [run unattended](https://www.uipath.com/blog/rpa-use-cases-part-one-unattended-robots), meaning they can operate in the background, 24/7, handling all the agonizingly manual processes legacy tools typically require.

**Modernize and connect legacy technology**
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.

With low code, enterprises can modernize their legacy technology stacks without ripping them out and replacing them. 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.

**Digital transformation**
Forgive the buzzword, but for enterprises, digital transformation is a serious pursuit. Many enterprises are still operating on paper and, if not paper, 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 in this [Twitter thread](https://twitter.com/radiomorillo/status/1405707879810748416), many organizations still use Excel. Rather than use a modern database tool, enterprises (and their employees) use a tool that lacks version control and can't handle the thousands of rows necessary for their purposes.

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

Low code is in your future (even if it isn't *the* future)
----------------------------------------------------------

Big brain, 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, simple thing. Well, it won't. That doesn't mean, however, that low code won't create incredible change.

Low code will transform the field of software development by empowering developers to choose when and where they want to spend time hand-coding. With low code, developers can build less and architect more. As more developers adopt low code, the industry will shift in big, unpredictable ways.

Full-time developers, armed with low code (or arming business users with low code), can re-focus from solving simple problems to solving complex problems. The effect of this reallocation is hard to understate and hard to predict. Developers[ run the world these days](https://www.forbes.com/sites/glennsolomon/2020/06/23/why-developers-are-fueling-the-next-1-trillion-software-wave/?sh=1b904d451a31) (see Stripe, Twilio, Atlassian, Datadog, MongoDB, etc.), so imagine if these [kingmakers](https://www.amazon.com/New-Kingmakers-Developers-Conquered-World-ebook/dp/B0097E4MEU) shifted their internal tool development efforts (30% of their time) toward changing the world. And that's only one use case for low code!