“Low-code is a black box, and I will hit the wall at some point. It’s limited and only works if you follow a template. It’s not coding at all.”
These were some of my thoughts ten years ago before I decided to give low-code a chance. I was very skeptical, and I decided to learn more about it because I wanted to have informed conversations about the topic. Guess what? I’ve changed my mind, and today I am a huge advocate for low-code.
The OutSystems Developer Conference is back
Join us on June 21-22 in Denver and prepare to get inspired, test-drive the latest features of OutSystems, and take the next step in your career.
A few years later, and thinking a bit more about this controversial topic, I realized many of these objections to low-code are triggered by the fact that low-code means many things to many people. Many “low-code” tools target different challenges and require different levels of technical proficiency, like website generators, form builders, API connectors, database builders, workflow automation, and more.
Recently, we have started to hear about low-code for pro developers, as tools like OutSystems, Mendix, Appian, SalesForce, and PowerApps, rise in popularity.
I guess we could measure low-code tools based on the use case they cover. The more generic it is, the closer you are to a programming language.
For example, with Salesforce you get the CRM ecosystem; with Appian you get the workflow/business processes, and so on.
However, with tools like OutSystems or Mendix, you are able to manage the entire app development lifecycle, for enterprise apps in general. Mobile or Web.
As a proud pro-developer myself, I decided to share the reasons why I embraced low-code, in particular, OutSystems:
1. Code Extensibility
For someone who always enjoyed “being in control”, I first struggled to change my mindset to use a visual language. Being able to extend it with my own code was one of the things that made me stick with it.
OutSystems is open by design to allow all layers of applications to be extended with custom “traditional” code: front-end, back-end, database, and integration.
2. Easy Integration
No software products exist in silos, and we constantly need to integrate with open-source libraries, 3rd party APIs, legacy data stores, and much more. With each integration comes a new boilerplate code to handle the specific requirements of each dependency, and this code requires maintenance whenever the dependency changes.
My first integration was with an existing Database (I had my data already), and it was mind-blowing!
OutSystems abstracts the boilerplate work by providing templates and ready-made connections to popular services and databases like Salesforce, SAP, Microsoft, etc. And all of these out-of-the-box connectors are designed for reusability, maintainability, and ease of change. Besides these connectors, the OutSystems Community offers tons of other pre-build connectors in Forge (OutSystems Code repository), and it’s also possible to build our own connectors due to code extensibility and API integration.
Not to mention the simplicity of consuming and exposing REST API or how easy it is to import any Swagger or OpenAPI specification from a file or URL. We basically just need to pick and choose only the methods that you want. It’s also possible to configure API authentication, basic or more advance like oAuth or JWT.
3. Repetitive Work Reduction
Software development is a form of self-expression, and it can be incredibly rewarding, particularly when you get past the roadblocks. There’s nothing more exciting than a “I built this!” moment. The downside is, software development is manual work and it can be very repetitive. This drains our energy and makes us fall into a vortex of frustration.
So when I first started exploring with OutSystems, I realized that most of the obvious/standard development tasks were being handled out of the box: authentication, authorization, form validations, basic security, error handling, CRUD screens, etc.
And this happens because, as a platform, OutSystems is a visual language that abstracts other languages similar to how Java or C# abstract Assembler.
This allows us, developers, to focus on the WHAT rather than on the technical details of the HOW.
4. Getting Things Done
The drag-and-drop nature of low-code and its fast deployment capabilities enable developers to put together not just a prototype but a working solution really fast. Why is this important? Well, in most cases, what delays the software development process is:
- Clients don't know what they want or are unable to translate their idea into developer lingo;
- Users change their minds all the time (the changing requirements saga).
So by having a quick prototype up and running, users can give their feedback in a much more straightforward way and we, developers, can then turn that "prototype" into the end product faster, aligned with the user's needs from the very beginning. This is a game-changer and really impacts "getting things done".
5. Front-End, Back-End, and Deployment in One Platform
Unless you’re specialized in a specific area, being a software developer means you are a generalist and work with different tools, technologies, and programming languages to handle front-end, back-end, and deployment. This can be overwhelming because the IT world is in constant evolution, and we need to learn new things all the time.
With OutSystems, I rely on a single tool for building UI, relational databases, data structures, logic, and integrations connecting with external systems, all visually and with the flexibility of going under the woods when needed.
6. Unified Experience while Developing for Different Platforms
Software development is a very complex world, and besides what has been mentioned above, developers need to handle multiple platforms - web, desktop, hybrid, mobile, iOS, Android, etc.
It’s amazing how I never had to learn Xcode to build an iOS app, and from the same code, I could extract the API or APK packages (iOS or Android) and submit them to the app store using the regular submission mechanisms.
Security is a top concern when building enterprise software and it involves a lot of work on different fronts.
In my journey with low-code, when I got to the point of considering it as a serious tool, I was concerned about security:
“Low-code provides a lot of abstraction and automation, but how secure are the apps we build with low-code? What are the flaws?”
I learned when using low-code tools, things like using up-to-date, secure libraries and frameworks, secure access to databases, handling exceptions and errors, authentication and authorization, encoding and escaping techniques, application and system auditing, were carried out and handled along the way by out-of-the-box mechanisms. On top of this, I also learned that it’s also possible to extend this “basic” level of security with customized code to achieve advanced security levels.
Last but not definitely least, I confess that when I started, part of me felt I was betraying the developers’ alliance but then I found the OutSystems Community and that is when I realized there are so many pro developers like me who took this step.
Although the number of developers using low-code is growing year over year, they’re still outnumbered by traditional developers. So, the communities that form around these platforms are naturally strong and supportive.
As a newbie, I had to rely on forums to ask my questions and I always got fast responses, with different perspectives and solutions to my problems. This made me grow so much that at a certain point I was the one helping and unblocking others. Today, the community feels like family and it’s where I find my people and geek out around low-code. From the outside, people sometimes say that we seem to have been “brainwashed” because everyone is passionate about it.
On a Final Note
Low-code doesn't mean easy, but for sure, it means faster and more efficient. Deep technical skills are still needed to succeed on these platforms while building enterprise-grade applications. Over the years, low-code gained traction, and more businesses learned about its benefits over traditional coding practices. It allows you to keep the critical elements of traditional coding solutions — such as flexibility and customization — while saving considerable amounts of time.
If you're still not convinced, why not try low-code for yourself? OutSystems' free edition is free forever, and it's a great way for you to see what developing with low-code is really like.