Low-Code and the Road to Software Enlightenment: Part 1

The Gartner Hype Cycle is arguably one of the most astute observations about the world of technology — new technologies often get hyped up to dizzying heights, only to come back down to earth when the hype is separated from the reality, and the real benefits of the new technology are appropriately harnessed:

image

The world of low-code application development platforms has enjoyed its meteoric rise in hype in the past few years, and it feels like the business world is finally starting to see past the hype and learning how to use low-code for sustainable business benefit.

The promise of low-code is to eliminate the act of writing code from the process of creating software to the greatest extent possible — and instead, favoring visual point-and-click tools for creating software. In doing so, the idea is that organizations can reduce the need for scarce and costly software developers, and empower so-called business “citizen developers” to build their own applications.

Unfortunately, as the low-code Kool-Aid is wearing off, many business and IT folks alike are starting to realize something that software thought-leaders have known for decades: In many scenarios, writing code is by far the most efficient and easy solution to a software problem, and there are countless everyday use cases where a low-code/no-code development tool is simply not the right tool for the job.

As JourneyApps is nearing the launch of OXIDE, our next-generation IDE, we are exploring the “dreams versus reality” of low-code, and showing how the industry can chart a more enlightened course for software development. This is our first installment of the series.

Low-Code is a Great Solution for “Simple Apps”

Low-code platforms are inherently limited — they essentially achieve simplicity by allowing citizen developers to assemble applications using “building blocks” that are provided by the platform, primarily using a visual point-and-click interface.

This approach works reasonably well for “simple apps”. We can roughly define a “simple apps” as apps that:

  1. Don’t have many “screens”
  2. Are typically built by a single developer
  3. Do not need very complex business logic
  4. Either don’t require any integration, or don’t require highly customized integration.

The Value of Low-Code Quickly Diminishes When Venturing Beyond “Simple Apps”

Due to the inherent limitations of specifying application customizations with visual point-and-click “building blocks”, most low-code and no-code platforms quickly hit a wall as application requirements become gradually more advanced.

It either becomes impossible to continue using the low-code tool for the more advanced use case, or it becomes incredibly convoluted — low-code becomes more of a hindrance than a help.

image

The agonizing thing here is that project teams often run into this problem very deep into a project, when a lot of sunk cost has already been invested. The ninety-ninety rule hurts even more with a low-code platform.

“Hold a Second, My Low-Code Vendor Promised Me Pro-Code Extensibility!”

Some of the major low-code vendors try to address this problem by allowing apps to be extended with “professional code”. The problem is that the professional code environment tends to be incredibly complex, negating much of the benefits of rapid development with the low-code tool. In other words, development velocity slows to a crawl:

image

The Gartner Take

It’s really no surprise that Gartner says in its report “Low-Code Development Technologies Evaluation Guide”, that low-code development platforms mostly support “departmental and workgroup applications” and that “through 2024, at least 75% of low-code application development efforts will be limited to small- to moderate-scale projects supporting non-mission-critical workloads.”

Gartner adds that “Enterprise Class” applications likely sit “outside low-code tool capabilities”.

image

The Low-Hanging Fruit Has Been Picked. The Harder-to-Reach Fruits Remain

We believe that generic low-code and no-code platforms have saturated the market for simple apps — or what Gartner calls “departmental and workgroup applications”.

The thing is, to thrive in the coming decade, companies need a sustainable solution to addressing the use cases that lie beyond simple apps.

Whereas the 2000s signaled the coming of age of the Internet, and 2010s saw mobile/apps and SaaS/Cloud spreading to ubiquity, we believe that the 2020s will be the decade of automation. Many of the automation challenges that are coming down the road will require the development of a huge range of non-trivial software — not primarily simple apps.

image

A Real-World Example of Where Code Is King: Industrial Field Apps

JourneyApps is focused on the industrial segments of the software application development market — industries such as Oil & Gas, Mining & Metals, Chemicals, Utilities, Supply Chain, Construction and High-Tech Manufacturing.

As a result, we have seen first-hand how industrial companies try to use low-code/no-code tools to build their software, and quickly run into a wall.

Industrial companies often have workers in the field performing complex work on complex assets — and if these companies want to digitize and automate their work processes, the complexity of the required software applications quickly climbs.

image

Let’s look at some of the reasons why. Industrial companies…

  • … are engineering-heavy and their use cases are often very data-intensive (in particular, involving complex relational data due to the complexity of their products and the work that their engineers need to do) and involve complex operational business rules (and therefore complex business logic in apps).
  • … often have distributed operations (requiring asynchronously moving complex relational data between the field and the cloud, or between field and on-premise systems).
  • … often have very heterogeneous IT systems (requiring highly customized integration).
  • … often require nonlinear UI flows, due to the unpredictable nature of field work on complex machinery.
  • … sometimes have to interface with hardware protocols, which can involve many edge cases (different standards for different equipment) .

This is a perfect example of the kind of environment where low-code/no-code platforms quickly hit their limits and become very convoluted to use (or even impossible to use to solve the problem at hand).

Conversely, it’s an environment where code is king: When it comes to things like working with relational data, complex business logic, and custom integration, writing code is actually the simplest way, and by far the most efficient and practical way to solve the problem.

We Just Scratched the Surface of Low-Code’s Problems

The trade-off between writing code and avoiding code is not the only reason why a low-code platform may not be the best tool for the job. As we have written about before, there are several related drawbacks to low-code/no-code platforms. Here is a quick refresher on some of the major drawbacks:

  • Vendor lock-in — the inability to extract readable code from a low-code platform means that moving an existing app to a different platform is virtually impossible. For example, Google left its Google App Maker customers stranded when they shut down the product in early 2020.
  • Debugging is difficult due to a low-code platform effectively being a black box.
  • Low-code platforms often have a steep learning curve due to their proprietary nature.
  • Developers often oppose low-code platforms, considering them to be “resume-killers”.
  • The future evolution of low-code apps is at the mercy of the low-code vendor.

If Low-Code Struggles with Complex Apps, and Pro-Code Has Big Challenges Too — Where Do We Go From Here?

The fact that the value of low-code platforms quickly dimishes as apps become more complex does not mean that “pro-code” development is the answer.

“Pro-code”, or traditional professional software development, simply cannot scale to meet the rapid rise of digital business and booming demand for software development inside companies. Traditional professional software development is highly complex, tends to result in very long projects, is very expensive, and requires a very high level of skill, while there is a scarcity of talented software developers.

Therefore, there must be a better way than either low-code software development or pro-code software development. Fortunately, there is an answer. Stay tuned to our series “Low-Code, Code and the Road to Software Enlightenment” to learn how this dilemma can be solved.

Read part 2 of our series here.


← Back to all posts

Get notified when new articles are published

Get in Touch

We'll follow up with you to schedule a brief call.