10 Challenges Facing Low-Code Platforms (And How We Solve Them)

While low-code platforms offer a clear value proposition to companies, the typical low-code platform comes with noteworthy downsides and trade-offs, as Peter Wayner at Infoworld and Matt Heuser at TechTarget recently wrote about. Indeed, companies should exercise caution when selecting a low-code tool as their development platform.

Fortunately, not all low-code platforms are created equal: JourneyApps has a unique approach which addresses many of the common pitfalls and limitations of typical low-code platforms. Here is a round-up of 10 typical low-code concerns and frustrations, and how JourneyApps addresses each of them:

1. Low-code limitations will back you into a corner

The concern: When the project (app) was originally scoped, the low-code tool met the project requirements. However, as enhancement requests come in, it became impossible to satisfy those enhancement requests using the chosen low-code tool.

How JourneyApps addresses this concern: All platforms have their limits, but we have implemented our platform in the most extensible way possible using as many open technologies as possible. Take our mobile and Windows containers, for example: They’re powered using HTML, JavaScript and Electron/Cordova. Developers implement their app code in JavaScript and extend it using JavaScript, and as such, can do things like connect to MQTT streams using WebSockets.

We also have an extensible frontend framework implemented in React, so anyone comfortable with React can implement their own UI components. Lastly, our CloudCode serverless compute environment is built on top of AWS Lambda using Node.js, and developers can include any npm package into their CloudCode tasks, essentially making their server-side environment infinitely extensible.

Core to our philosophy is to provide developers with the most extensible tooling so that they can meet future, unknown requirements that were not included in the original scope.

2. Low-code apps are a black box when it comes to debugging

The concern: It’s hard to debug apps built on low-code platforms.

How JourneyApps addresses this concern: There are two parts to this problem: Debugging your frontend code and debugging your backend code. With regard to the latter: In JourneyApps you can run your CloudCode tasks locally using your favorite debugger like Chrome DevTools. We also provide verbose database logging in Chrome DevTools for frontend performance debugging, and plan to add support for inspecting variable state directly in DevTools too.

3. Low-code apps are bloated and inefficient

The concern: Low-code introduces bloat to your codebase and ultimately slows down your app and/or prevents you from working with large datasets.

How JourneyApps addresses this concern: With software frameworks in general, there are areas where supporting all the edge cases out-of-the-box can slow things down. Ultimately, if things become slow, users lose productivity. At JourneyApps we continuously test the performance of our apps on real devices with large data volumes to make sure that we meet stringent performance benchmarks.

Since the JourneyApps app-side architecture runs a fully-fledged database on the device, the responsiveness of the apps remains excellent, even with large datasets. We typically test against our most sophisticated app component, which is our advanced data tables. These tests measure both read and write speeds, and with our 2019 test results, it was trivial to work with ~100,000 database objects in a data table on an iPhone X — a testament to the high performance of our platform.


4. The learning curve of a proprietary low-code tool

The concern: Low-code is not taught in schools, so your team will need to spend time learning how to use the tool.

How JourneyApps addresses this concern: Most of JourneyApps feels more like a JavaScript framework that you need to learn versus an entirely new ecosystem. Take our CloudCode component for example — it’s basically pure Node.js. With the exception of our journey and DB APIs (which are very easy to use and therefore learn), it really feels like you’re working in Node.js. The same holds true for our frontend, where you implement your logic using TypeScript or JavaScript. The above, combined with our IDE’s powerful, proprietary auto-complete, drastically reduces the learning curve.

5. Mismatch in coding expectations for complex workflows

The concern: Low-code platforms often promise that you don’t have to write code, but then many non-trivial use cases require significant code to be written.

How JourneyApps addresses this concern: JourneyApps has a different philosophy: We take a code-first approach. We don’t create the unrealistic promise that more sophisticated use cases can be implemented without any code. Instead, we focus on making coding as productive and easy as possible for everyday developers. We have great auto-complete, APIs, and helper functions. There is no limit in terms of what you can do with code in JourneyApps. You can build really complex workflows and systems without going outside of the “golden path” paradigm of the platform.

6. Visual development just doesn’t cut it for complex use cases

The concern: Sometimes, using a visual language like Business Process Modeling Notation (BPMN) to build business logic becomes so complex and unwieldy, that it would be much faster and easier to just write a simple piece of code to solve the problem. Indeed, low-code and no-code platforms can sometimes be more of a hindrance than a help.

As Sebastian Dolber, CEO and founder of software development service provider Astor Software told the SDTimes: “Low-code/no-code can be customized only to some extent and legacy systems written with code, libraries and APIs much more than often have complex business rules that are hard to port to no-code platforms.”

Peter Wayner puts it very elegantly: “Low-code options tend to push the … story: You’re not coding when you’re specifying the algorithms, connecting the database, and filling in the parameters. That’s just configuration fluff and everyone knows that configuration is easy enough to do from your smartphone in a loud bar. But the reality is that those keystrokes might take days or weeks of fiddling until they actually do what they’re supposed to do. The vendors don’t want us to consider it ‘work’ even if it takes longer than actually doing the hard ‘work’ of writing code.”

How JourneyApps addresses this concern: Again, with our code-first approach, we support the easier path of simply writing some code to address complex use cases. Therefore, JourneyApps is a great fit for complex use cases.

7. Difficulty in getting data out of a low-code platform

The concern: Getting data out of a low-code platform to a local database can be problematic.

How JourneyApps addresses this concern: We provide a real-time database replication tool to make all of your app data available in a downstream SQL Server replica.


8. Vendor lock-in is a problem

The concern: A black-box proprietary system where it is difficult to move your code out, creates dangerous vendor lock-in risks.

As Peter Wayner writes: “Sometimes starting up one of these low-code platforms feels like joining the mob. It’s easy to join but hard to leave. The price for doing less work and standing on the shoulders of giants is that you become beholden to the giants.”

A common concern is that you cannot get readable or usable code out of a low-code platform, making it very hard to move your app to a different platform.

How JourneyApps addresses this concern: Unlike other low-code platforms that either (a) don’t give you any access to your apps’ source code, or (b) create a mess of generated spaghetti code that is basically impossible to reuse; implementing apps on JourneyApps is based around clean, readable code — and you can even store the code in your own GitHub repositories, using the GitHub integration built into the platform.

9. Integration can be a problem

The concern: Sometimes it’s just not possible to integrate with some systems due to limitation in your low-code platform.

As Matt Heuser writes, “The idea of calling an API in order to perform some common task, such as authentication … is so common that it is taken for granted. Even if the platform doesn’t supply it, programmers know they can code an authentication themselves – unless they aren’t able to. Whatever it is you want to integrate with, be it a system used in accounting, HR or social media, prove it with a demo before wading too deep into low-code development. And don’t get it 90% there. Even 99% is not good enough. With a low-code platform, that troubling last bit of integration might not even be possible. Prove it before moving forward.”

How JourneyApps addresses this concern: The JourneyApps platform provides a soup-to-nuts server-side compute environment built using Node.js. This means that integration with any TCP or HTTP service is possible, and we have yet to come up against an integration requirement that can not be implemented on our platform.

10. Developers oppose low-code platforms, viewing them as “resume killers”

The concern: Developers don’t think that a proprietary visual programming platform advances their careers, and therefore they oppose its adoption.

In a recent eWeekChat held by the tech publication eWeek on the topic of no-code and low-code development, Jason Bloomberg, President of analyst firm Intellyx, remarked that “many hand-coders still scoff at the whole idea [of low-code]”.

In the same discussion, Mike Hughes, Senior Director of Product Marketing at the low-code vendor OutSystems, commented that “we just don’t get many devs who are excited to call themselves low-coders — same issue for CIOs who have to justify buying the platforms”.

In last year’s edition of the same eWeekChat, Sumit Sarkar, Director of Product Marketing and Developer Relations at Progress Software, mentioned that he “surveyed over 5,000 developers to get their sentiment about these [low-code] platforms and over 60% were negative. Retraining will be both a technical and cultural challenge.”

How JourneyApps addresses this concern: Since JourneyApps is based on open technologies such as JavaScript, TypeScript, Node.js, git and React, it actually helps developers to build their resumes, rather than confining them to a non-coding skill-set tied to a proprietary platform.

In Conclusion

While there may be some apprehension in some corners to implementing low-code app development platforms, it has undoubted benefits for IT groups. Aspects such as lack of customization and difficulty in integration have been addressed by leading platform vendors. While some of these concerns are warranted for some vendors, JourneyApps has taken a unique approach to side-step the frustrations and downsides of other low-code platforms.

← Back to all posts


The development platform

for industrial apps

Try For Free