The Pros and Cons of Low-Code Development Platforms

By Joshua Gross, 18 March, 2022

There are two general styles of developing apps, programs, webpages, and live services. As you might infer from the title, they are low-code and high-code.

High-code is what you might think of as "traditional" development. A person or a group of people sit down and type out the code they're using for the application they're creating, whatever that application may be.

It could be anything from a simple Hello World script or a webpage with just a bit of text on it to some of the most complex software on the planet.

What, then, is low-code?

Let's dig in and find out.

What is Low-Code Development?

Low-Code is a means of development where you use tools and pre-made modules to perform the functions you want.

Consider something like cooking a meal. In high-code development, you might gather all the ingredients to make a broth from scratch, bake your bread, and cook a meal using base ingredients. (For a more extreme example, you might start by growing your grain and vegetables or raising the animal you use for meat.)

A low-code version would be buying a can of soup as an ingredient in a casserole or purchasing a boxed mix to bake bread in a "just add water"-style product.

Both will result in a meal.

One might have a tastier or more customized meal than the other, but many people might not care about the difference.

You don't always need to reinvent the wheel. When you want to develop an application, should you code a button from scratch or use a code snippet someone else made that includes all of the button's functionality, and you tie it to the action you want to have to happen when the button is pressed?

Low-code development can happen by using code snippets or using tools or platforms that have the functionality built into them. You might use a tool to build an application or webpage without ever looking at code directly. You might still need to interact with code to make the elements work together and code your functionality around them.

What Are the Benefits of Low-Code Development?

Low-code development comes in several forms, but they all share more or less the same array of benefits, with more emphasis on some over others depending on the angle. So, what are those benefits?

It can dramatically speed up how quickly you can develop a product.

At the barest minimum, typing in code takes time compared to copying and pasting the same code from another source or dragging and dropping a module that has that code in the back end in a visual editor.

Depending on how widespread the modules and functionality you're looking to use are, you might be able to make an entire app using nothing more than pre-existing code snippets.

In other cases, you might need to use manual coding for some features, but do most of your framework and elements using pre-developed modules and snippets.

Some estimates place the speed of low-code development at as much as 10x faster than traditional high-code development processes. Between templates, feature modules, and standardization, a business can bring a new idea to market significantly more quickly.

This process also facilitates a more agile and responsive business. You can, for example, combine a low-code development process with a Minimum Viable Product development model.

This strategy allows you to build a small, functional app, test it with an audience, receive feedback, and make changes in a shorter time than it would take to develop the MVP in a traditional high-code environment.

It helps minimize the incidence of errors and bug-fixing.

Copying and pasting (or using a module or template in a visual interface, which is practically the same) is a lossless code transfer. Even if you were to re-type the code manually, you might make errors.

Developing a helpful code snippet from scratch is even more prone to errors, both manual typo variety, and tactical functionality variety. There might be anything from a misplaced semicolon to an unexpected behavior you didn't plan for.

When using a code snippet, someone else (or many others) has already thought of, tested, improved, optimized, and expanded that module. It does what it needs to do, with whatever failsafe or backups it needs, and it works consistently every time.

Many development platforms use large libraries of modules, all of which work consistently and are tested to work together without bugs or errors. Some more expansive environments may leave more room open for issues you would need to troubleshoot or bugfix, but even that is much less of a burden than engineering everything from scratch.

It lowers the barrier to entry for your development team.

Depending on your choice of environment, developers can be both expensive and hard to find. Suppose you need an expert with years of experience in a particular language, framework, or background. In that case, they may be hard to find as they are in high demand and command a high salary due to the rarity of their skills.

When using a low-code development platform, you dramatically lower entry barriers. Your developers don't need to have exacting, specific knowledge of the code; they need to understand the core principles and functionality of programming in the environment. You can have developers who virtually never interact with code directly, and they will still be perfectly adequate developers.

Since the skill floor is lower, the base salary for your development team is too. You save money and can hire more people to work on the application from different angles simultaneously. You also save money on the speed of development, as mentioned above.

You have tighter integration with the user experience design.

Part of developing a new app, program, or website is the user experience. In traditional development, your coders might not have much experience with UX design, so you need to hire people with specific knowledge of user experience to change and optimize or skin the program from scratch.

Conversely, when you're working in a low-code environment, most modules will include the functionality and a template of how it can look. They might have skins you can assign, or you might easily code them to use CSS in an intuitive or centralized way. They may also have a tool designed for you to edit directly in a WYSIWYG style, again without touching the code directly.

All of this results in not just a faster development cycle but better-looking beta apps and trial versions in your MVP.

It can facilitate cross-platform accessibility.

Many low-code platforms can export a finished project in a form that works on multiple devices or ecosystems. In the case of web apps, they will function on any device – PC, Mac, mobile – that can access the internet. For more traditional apps and software, often, these low-code environments enable you to export versions for multiple platforms, using alternative versions of modules and code snippets.

In traditional development, if you want to have a PC version of an app, a Mac version, an iOS version, and an Android version, you'll need to make it web-based, or you'll need to make a minimum of 3-4 different versions of the app. You'll need these variations because each different environment uses different kinds of code, different dependencies and libraries, and different arrays of available functionality. In many cases, the features available in one ecosystem won't be usable in another.

Are There Drawbacks to Low-Code Platforms?

While these advantages are very potent, don't fall for the hype of thinking that low-code environments are universally better for development.

There are several noteworthy drawbacks to using low-code platforms or systems as well.

"Low-code isn't the future of code. It certainly has a place in the future and will be leveraged to make many applications. It will not replace other ways of creating software because low-code breaks down when the solution's complexity increases. We saw the same thing with Visual Basic in the '90s. VB was valuable, and a lot of software was written in VB. In the end, it was the complexity required by some applications that caused VB to break down and no longer be a good solution. Low code will be the same." – Thomas Stiehm, CTO of Coveros, via HackerNoon.

You may be constrained to just what the platform allows, limiting your functionality.

One of the most significant drawbacks to low-code development is the same as one of its best features: constrained functionality.

The use of code modules and drag-and-drop editors means it's easy to throw together something that works in a minimal amount of time. This process is incredibly beneficial for agile development and MVP modalities, but it falters when you want to do something that the platform doesn't support.

What happens then?

You generally have three options.

  • You can use custom code to create your new module for the feature you need. This strategy is slower, requires manual coding, and may not be possible on some platforms.
  • You can strip the feature out and not make it. This strategy limits the functionality of your final product and, if the feature was critical enough, can kill off an app idea.
  • You can migrate to another environment, potentially a different low-code platform or a high-code environment.

None of these are great options when investing heavily in a low-code platform.

You may end up locked into a specific vendor or environment.

Many low-code platforms use a relatively standardized set of code or a core language shared across other platforms and high-code development. However, that's not true of all of them. Moreover, some will only allow you to export finished products and may make it difficult (or, rarely, impossible) to export and transfer your base code to another system.

This means you often end up faced with a choice. Do you go low-code using code snippets and self-guided development, or do you use a platform that may lock you into their environment, implicitly or explicitly?

Neither is an excellent choice for many businesses.

You may encounter "black box" issues.

When using a low-code environment, you have code snippets pre-generated and usable through an editor. You can leverage this to your advantage by hiring people who don't have as much direct technical expertise. However, this puts you in a sticky situation.

Does anyone in your development team know what the code does?

It's rare for the significant environments with many users because someone (somewhere) looks it over and analyzes it. However, especially in the more DIY low-code development processes using untested snippets found online, there can be potential problems with unknown code. You may run into an issue where the modules you're using have unexpected code, unintended features, or even security issues.

If no one knows what the code does intimately, you never know what kinds of problems can arise.

Should You Use a Low-Code Development Platform?

The answer to this question is a resounding "maybe." The truth is, a low-code environment can be great for:

  • Simple or small apps with constrained functionality.
  • Agile development of a proof of concept or minimum viable product.
  • Experimentation with features or ideas.

However, as an app reaches maturity, complexity, logical burden, and uniqueness rear their heads.

The easier it is to make your app in a low-code environment, the less uniqueness and value your app will have when it's finished, and the easier it will be for someone else to copy it and invest slightly more to out-do you. It can, in that sense, become a detriment to use a low-code environment for final development.

Generally, a low-code platform is excellent for getting started, but at some point, you will want to transition to a high-code environment for finishing your project. However, if you have further questions, feel free to reach out to us to discuss them.