Adopting Low Code for Developers: 5 Things to Consider
Low-code tools have evolved to support more complex applications and are being more widely adopted by professional developers, even as they maintain their appeal to the “citizen developer.” But the two sets of users won’t be satisfied by the same set of features.
Some low-code development tools (like those from Salesforce.com and Zoho) originated as tools for business users; others (Outsystems and Oracle) as tools for developers. While the type of applications you create with each might look similar, differences in the development experience play an important role in their adoption.
While the potential productivity gains of low code are real and earning lots of attention, professional developers bring higher expectations from their development platform than business users, based on best practices they developed over the years. We have experienced this with our own development teams as they’ve adopted an Oracle low-code platform for building Oracle’s SaaS set of apps. Based on our experience, we wanted to share tips that can help your development team adopt low code for enterprise-scale apps. In determining whether the adoption of low-code tools will go smoothly with professional developers, consider these five criteria.
1. Direct Access to Code
Professional developers love to code. Looking at the code helps them understand what’s going on and debug problems in familiar ways. Many low-code tools, however, act as a black box: You use the visual development tools and the platform does its magic. The code that makes the app work is hidden. This approach can cause problems if something in the app goes wrong or when the platform doesn’t support functionality that developers need.
Professional developers feel much more at ease with tools that provide direct access to the code. They can dive into the code view to understand what exactly is going on and even enhance the platform’s out-of-the-box functionality.
Check if the platform you’re using makes the code of the page layout and visual business logic flow, accessible and modifiable. Does it let developers code directly? Does it use standard languages such as JavaScript and HTML to do these modifications? Can developers enhance the functionality at both the UI and business logic layers?
2. Team Development and CI/CD
Look for low-code tools that integrate and support capabilities that enable agile methodology-based development that developers have grown to love. Those include git-based version management for collaborative team development, ability to automate application testing, code auditing and creating CI/CD pipelines for faster delivery of app changes. For example, check to see if developers can directly generate automated tests for business logic that was developed in a declarative way and how they will fit with practices such as test-driven development.
3. Modularity
When building enterprise-scale apps, low-code tools should support multiple developers working on the same application — and in many cases on the same pages — at the same time.
Your tool should reduce situations where one developer’s changes could conflict with those of another. This is where modularity comes into play. Breaking down a big page into areas that can be developed independently and then composed into a complete solution helps eliminate conflicts. Think microservices instead of a monolith.
If reducing such conflicts is important to you, look for tools where two developers can add functionality to the same UI page while each defines his/her logic in a separate file. Some tools offer page fragments, which provide reusable “sections” of a page that can be developed independently and then composed into a single page.
4. Industry Standards
Most developers prefer technologies with wide market adoption so that the time they spend learning a new tool and framework will serve them in their next job too. This also helps them during the development process because it’s easier for them to find help when they run into questions.
As such, developers prefer low-code platforms that use popular languages and standards rather than proprietary technology. If you are an IT manager, sticking with nonproprietary platforms makes it easier to find and recruit qualified developers. Look for platforms where development is done with standards like JavaScript/HTML/REST. That way, developers who run into something they don’t know how to do can just search popular JavaScript forums for the answer. When they need to access an external system, they just need a standard REST API. This will also let them develop the backend for their applications with their favorite server-side language and easily access it from the tool.
5. Extensibility
A good low-code platform will pack a great deal of functionality, but you’ll always run into something that’s not available out of the box, such as a unique UI component or a piece of complex logic you need to implement. Platforms that rely on industry standards will make extending them much easier. Ideally, you’ll be able to pick up existing components and libraries and easily plug them into the platform, where they can be invoked from the low-code tool’s declarative interface for creating UI and business logic.
Low-code platforms can help developers deliver apps faster, but it’s important for organizations to adopt platforms that support the way their developers like to work and support modern practices. This concept has guided us as we created Oracle Visual Builder. You can try it for free, and even take a workshop to see these concepts in action.