What is Low-Code Development?
Low-code development is a modern paradigm where applications can be created through graphical user interfaces. Instead of mainly writing code in a text editor, low-code developers usually rely on visual, drag-and-drop types of tools for building user interfaces and defining the logic of their applications. The top priority of low-code development is to reduce the complexity and overhead of traditional web-development, creating a simplified development experience that enables a faster delivery.
An important premise of low code—and one that distinguishes it from similar paradigms such as no code—is the flexibility to extend the codebase using a traditional programming language. This is low code’s trump card, as it helps fill the gaps for edge cases where the visual toolsets of low code might be limited or impractical. For these scenarios, developers have the option to switch to a standard programming language where they can enjoy better control over the application logic, as well as potentially leverage the wealth of existing resources tied to that language, such as SDKs, packages and libraries.
Advantages of Using Low Code
As described previously, the main value proposition of low-code platforms is their ability to significantly increase development speed, often cited as being several times faster than traditional development. This comes with its fair share of implied benefits: faster time to market, better ROIs, etc. The productivity and generation tools that they provide can be a game changer, allowing businesses and organizations to potentially make a release in a matter of days, whereas accomplishing the same goal could take weeks or months using traditional development methods.
Low-code platforms are also keen on offering a uniform, simplified ecosystem, providing a complete toolset for you to manage the full Software Development Lifecycle from day one. With OutSystems, for example, other than the standard development IDE, you also have complementary tools such as environment-specific consoles for operations and monitoring, a dedicated DevOps console for simplifying deployments, and architecture validation tools, just to name a few.
Misconceptions About Low Code
There are several common misconceptions tied to low code. I can confirm this from my own experience and from introducing several people to the concept. The first time you hear about low code, even if you are enthusiastic about it, you can’t help but feel a tiny bit skeptical about its supposed value. After all, most people will agree that software development is not a trivial task. Especially for the hyper-technical, wizard-like experienced developers who are used to dealing with countless lines of code per day, it can be particularly challenging to visualize a way in which their complex problems could be tackled using more muggle-friendly tools such as drag-and-drop workflows and UI builders.
In general, these misconceptions can be summarized in the following statements:
2. It is impossible to integrate with X. Every company has its own set of tools and systems that it uses or plans on using to accomplish its business goals and operations, each with its own set of APIs and quirks for integration. Every respectable low-code platform provider understands this, and therefore offers several industry-standard methods to integrate with external systems, such as including the ability to consume or expose REST/SOAP with full control over incoming/outgoing requests, compatibility with dedicated SDKs and connectors, etc. Platforms also often include support for integrations with popular cloud services in AWS/Azure/GCP, as well as community-driven resources such as forums and open-source components to share knowledge and accelerate common integration patterns.
3. You don’t have enough control over Y. The key focus of this misconception is the word enough. Granted, due to the way they are implemented, low-code platforms aren’t designed to give you full unrestricted access to the core code they generate for applications. Then again, that is not their intention. Much like a core goal of cloud providers like AWS and Azure is to reduce the pains related to infrastructure setup and maintenance, low-code intends to minimize the boilerplates and verbosity attached to writing software from scratch.
The best way to think about it is like a high-level compiler: much like a Java developer doesn’t care about directly modifying the resulting bytecodes, a low-code developer doesn’t (or shouldn’t!) care about modifying the underlying code that is generated for their applications. The promise is the same: if the logic you defined is correct, there is no reason for your program to behave differently than expected. Anything that fails to meet that promise is a bug, much like the ones you can find in every single core language out there. The only difference, however, is that with low code you get the added peace of mind of customer support, frequent platform updates, and often SLAs to make sure that the platform lives up to your expectations.
Just as a disclaimer, I’m speaking from my experience using OutSystems, so other low-code platforms might offer their own special capabilities, advantages and limitations.
Unique Challenges of Low Code
Much like every other technology out there, low code doesn’t come without its own quirks and unique challenges. In order to succeed, you need to get used to working with things in the way they are dictated by each low-code platform to avoid the pitfalls. Although these are rarely deal breakers, they are certainly elements that need to be given special attention for onboarding and training purposes.
Despite all of the advantages described here, it’s also important to know that there is no silver bullet. While you can, in theory, build anything using a low-code platform like OutSystems, it might be somewhat impractical for certain use cases such as building mobile games, where you might be better off using specific frameworks and SDKs tailored to those types of applications. Nevertheless, you could still leverage the power of low-code platforms for those cases in some fashion. For example, you can use them for storage, building back-office applications and/or core back-end services, just to name a few examples.
One major point to remember—and one that is often repeated inside Capmation—is that the speed of low-code development doesn’t eliminate the normal steps of a healthy Software Development Life-Cycle. For a project to be successful, just like a traditional development project, there needs to be a proper respect for and adherence to processes such as gathering requirements and architecting the solution. You will hear that low code is like a fast sports car: it can take you places really fast, and that includes going really fast into a wall if you’re not paying enough attention. The takeaway is that when you follow the process, you can fully harness the incredible power of a low-code platform to supercharge your business or organization.