Low-code is a tough sell for some developers; they have plenty of reasons to push back when it comes to these platforms. They’re used to coding, not designing flows or dragging and dropping interface elements. They prefer being in the weeds and sticking with what they know (like all of us, like me). And because low-code is easy to use and its barrier to entry is low, developers readily imagine an army of uneducated dragger-droppers storming their castle, beheading them, and claiming the title of software engineer for themselves. A frightening visual if I ever imagined one.

But beheadings are far from nigh, and the reality is much rosier than previously pictured. Once developers get on board with low-code tools, they have quite a few nice things to say about them (and yes, even of our competitors, too). To write this post, I rummaged through recent developer feedback on TrustRadius and Gartner Peer Reviews to discover the qualities of low-code most favored by developers. Here’s what they liked (from least-frequently mentioned to most).

9. Community


Photo by rawpixel.com from Pexels


Low-code tools remain niche; the developers who use them are small in number. And the lack of interoperability among low-code platforms leaves developers with even fewer peers to consult. As a byproduct, the communities that form around these platforms are naturally strong and supportive. Developers who begin to work with OutSystems cite the community as a welcome source of help and open communication with the platform team. Similar communities exist for Mendix, Appian, and other low-code platforms.

8. Generated Code > Hand-Written Code

I doubt this is true in all cases, but a handful of reviews indicated that low-code platforms generate code that executes faster than code written by hand. This isn’t too big of a surprise; as application platforms, low-code vendors see huge cost-saving benefits in performing optimizations. Depending on the vendor and the client’s unique configuration, software built with low-code may execute on the vendor’s infrastructure. In those cases, reducing CPU and memory load is a fiscal imperative and not just good business practice for the low-code company.

7. Skip the Prototype


Photo by picjumbo.com from Pexels


In agile-powered teams (every team on Earth, right?), new features and products undergo a prototyping phase. This stage in development allows developers to demonstrate the product to clients. After clients sign-off on the prototype, developers implement the prototype in code and connect it to live services. But the drag-and-drop nature of low-code and its exceptionally fast deployment capabilities enable developers to skip the prototype phase. Rather than build a non-functional mock-up, low-code enables developers to construct the working feature in the same amount of time.

6. Easy Collaboration

No more merge conflicts

As a handcrafting developer, the part of my job I hated most was dealing with merge conflicts. For those un-indoctrinated, wise developers use version control systems to separate their unfinished code from the deployed product. Once new code is ready to become part of the product, developers must merge their changes into the master branch. Occasionally, two or more developers modify the same files after beginning independent work, and the version control software cannot determine which changes to incorporate and which to delete. This results in a merge conflict.

Merge conflicts lead to stress, additional workload, and at times: bugs. Low-code platforms simplify the merging process by remaining visual (rather than text-based), and by providing powerful version controls directly in the IDE rather than as part of an external tool like Git or Subversion.

5. Web, Mobile-Web, and Mobile All-In-One


Low-code tools generate web-based applications and services. Due to low-code’s web-focused nature and hybrid mobile technologies (hybrid tech allows developers to build native mobile applications with HTML and JavaScript), low-code is uniquely positioned to generate desktop and mobile applications from a single codebase. I can’t speak for all developers, but for me that level of efficiency borders on titillation. All kinds of technology have championed the promise of writing once and running everywhere, but few come as close to fulfilling that promise as low-code.

4. Easy Integration

No software products exist in silos; developers integrate open-source libraries, 3rd party APIs, legacy data stores, and much more into their products before all is said and done. With each integration comes new boilerplate code to handle the specific requirements of each dependency, and this code requires maintenance whenever the dependency changes. Worse yet, microservices are growing in popularity (decentralized services that perform limited but focused tasks). The flourishing number of these services require more inter-software connections than ever before. Yeesh.

Low-code platforms abstract the boilerplate work by providing templates and ready-made connections to popular services and databases. Some platforms go beyond the connection logic by proactively verifying the integrity of a given integration. The tools can alert the developer to any problems they encounter when communicating with the dependency. That’s nifty.

3. Up-and-Running Quickly

Up and Running Quickly

Sure, some non-low-code tools offer the advantages in this list, but few can bring the new developer up to speed as quickly as low-code. Thanks to its visual nature and underlying web technology, low-code is easily learned when compared to alternatives. To begin working with low-code, developers need only an understanding of web-based software and a brief tutorial of the tool itself. Rather than learning a new SDK or an entirely new programming language, developers primarily learn how to use a simpler, drag-and-drop friendly IDE. If developers can learn to write a series of special characters that instruct a machine to perform wizardry, certainly they can learn how to click and drag things around on a screen.

2. Fast Deployments

Harking back to an earlier point, software projects are highly complex. Equally complex are the deployment processes that allow projects to go live. For developers working in the weeds, a deployment sometimes looks like a nasty shell script that bundles the master code, pushes the code to servers, waits for a callback, and prays for imminent success and its long, prosperous life. Deploys can get even stickier; they may require application owners to post notices for scheduled maintenance, consume several hours as they upgrade databases, do backups, and who knows what else.

With low-code, the application platform handles the majority of DevOps tasks for the developer. With OutSystems, a complete deployment requires but one thing: the clicking of a single green button. A lot of work goes into automating deployment, and low-code does that hard work for developers.

1. Code Quick

No Speed Limit

Nearly all developers agree, the number one reason to switch to low-code is speed. Speed is not the result of any one factor. Several points on this list contribute to how quickly developers who use low-code platforms can build products. Quick deployment allows developers to get back to work sooner. Write-once-run-everywhere reduces the amount of work developers must do. Easy integration cuts down the time spent writing boilerplate code, and generated code that performs well and comes bug-free dramatically reduces maintenance requirements and time-to-production.

It’s not so much that low-code is fast, but that low-code removes the slow. Low-code platforms abstract or altogether hide elements of a developer’s work that result in crippling slowdowns. And where OutSystems depicts itself as a rocket, I think developers see it as a blade vigorously sawing at the ropes tying them down. Low-code does not accelerate developers; it frees them to move at their natural speed: fast.

If you’re a developer, what attracts you most to low-code platforms?