The low & no-code series – OutSystems: Inner infrastructure constructs
The Computer Weekly Developer Network gets high-brow on low-code and no-code (LC/NC) technologies in an analysis series designed to uncover some of the nuances and particularities of this approach to software application development.
Looking at the core mechanics of the applications, suites, platforms and services in this space, we seek to understand not just how apps are being built this way, but also… what shape, form, function and status these apps exist as… and what the implications are for enterprise software built this way, once it exists in live production environments.
This post is written by Patrick Jean in his capacity as CTO at OutSystems – a company known for its modern application development platform that stems from low-code app dev roots to now encompass a wider set of tools designed to be used through the entire fabric of the modern IT stack.
For this piece, we asked Jean to focus on low-code as it exists and works with technology that operates at the IT infrastructure layer.
OutSystems’ Jean writes as follows…
Let us start from first principles. We must remember that low-code providers (such as OutSystems) that track development changes and perform integration (the I in CI/CD) at the point of design and that that also provide application hosting platforms… provide the benefits of low-code application design with no-code infrastructure.
When enterprises use a fully integrated application development platform (with an application hosting function) they get the holistic benefit of being able to automate their change management process for applications and infrastructure, all in a single combined solution.
Wider benefits here distill very quickly to also include order of magnitude productivity increases… since developers can fully focus on the creative aspect of software development while being completely unencumbered from any infrastructure design or maintenance while still being able to deploy apps to modern cloud-native infrastructure.
Building up to infrastructure scaffolding
There are also low-code solutions that provide infrastructure scaffolding for application hosting (such as AWS Amplify). This is similar to the prior Rapid Application Development (RAD) approaches (that we might have known in pre-millennial times), which basically moved the starting point further along, but did not contain the benefits of a mature change management process. This is better than bespoke, high-code solutions but cannot match the productivity gains of low-code application development platforms with integrated app hosting.
TECHNICAL NOTE: To define infrastructure scaffolding, across the wider transept of software application development we can say that scaffolding typically describes any process, method of technique designed to create skeleton-level elements (hence the term scaffolding) for the application being built – and further, infrastructure scaffolding can be performed at the Command Line Interface (CLI), via some form of code generator tool, or (as see increasingly now) via a cloud platform service.
The benefits here with modern infrastructure scaffolding functionality is that ‘traditional’ developers (by which we mean something like pre & non cloud-native programmers) feel more at home using these tools but they only provide incremental value.
Down the CI/CD pipeline
There are also a number of infrastructure automation tools that provide the benefit of a ‘lower code’ (by which I mean not quite as low as low-code) approach to infrastructure as code, many integrating with Continuous Integration Continuous Deployment CI/CD capabilities. Hashicorp Terraform, AWS CloudFormation, Azure Resource Manager would be in this list, to name a few.
The capabilities within this group are varied (so it is wise to audit and evaluate each on their own merits at the outset) and the challenge is that our developer must still piece together the CI/CD pipelines and app development. So the developer is still spending time on cobbling together infrastructure, be it for the CI/CD pipeline or the application hosting, instead of spending that time on the creative aspect of software development.
Linking the DevOps toolchain
A common thread through all of these approaches is the ability to integrate (to varying degrees) existing DevOps toolchains, to automate the entire build-test-deploy-integrate-(test again)-enhance-repeat software application development lifecycle. This is table stakes whether you are doing high code, low-code or no code. Platforms that don’t have DevOps capabilities are not a fit for serious apps that enterprises need to solve any problem of significant complexity.
So coming full circle then, let’s remember that low-code application hosting platforms, with unified change management and continuous integration, have DevOps capabilities out of the box and some providers allow for integration with other tools such as Azure DevOps, JFrog Artifactory, GitHub etc.
Low-code with infrastructure scaffolding and IaC tools generally require an existing DevOps toolchain to be effective, so less beneficial overall.
Key & core takeaways
Low-code platforms with integrated application hosting with unified change management and continuous integration provide the best value, removing the need for any infrastructure design or maintenance, with the provider platform taking all this responsibility ensuring high availability, performance, security and compliance.
One critical point often overlooked, is how this benefits development teams ongoing, after the initial release of an application. With these types of platforms there are almost no ongoing maintenance costs at the infrastructure level, since the platform takes care of this. Teams can continue to focus on app functionality and direct benefits to users.
If there are key and core takeaway points from this level of the low-code no-code discussion at the infrastructure level, then it should be the question of how much a developer team needs to rely upon the wider aspects of change management plus DevOps plus CI/CD i.e. all the things we actually really need to make applications liveable, workable, flexible and manageable in the real world.
At its core, low-code infrastructure is a deeper topic than many may initially think, please dig deep.
