Efficient digital delivery: Where do no-code options play a role?
The way in which software is produced continues to change and evolve. We work in an industry where you can’t stand still for too long - otherwise you’ll get left behind. In a barely regulated industry, standards and practices have become de facto (rather than deliberate and ordered), usually driven by market investments from the big players.
Every now and again, we see more seismic evolutionary jumps than usual; often these involve the introduction of a higher-level language or stack - for example, C++ over Cobol, or cloud over on-premises. Predominantly these shifts push us to be more productive while writing less, and they're cumulative by building on the success of the shifts that have gone before them.
Today, another one is well underway with the advent of mature Low and No-Code tooling, and at Kainos - we're embracing it by ensuring we guide customers and partners to choose the right tool for the right job.
No-code vs low-code vs pro-code
To help describe our viewpoint, we'll break the types of coding approaches into three broad categories (although the realities are a little more nuanced). Broadly, the split is the relationship between simplicity and flexibility: the simpler it is, the less flexible it is, and vice versa.
- No-code: completely click-configuration, dragging and dropping entities within a User Interface (UI). These products don't provide the means to create with code or inject traditional programming artefacts. These tools offer the lowest barrier to entry (they're the simplest), and are also the least flexible. This is often cited as being performed by Citizen Developers.
- Low-code: a hybrid of UI led configuration coupled with a level of custom logic in the form of code "snippets", allowing the user to get somewhat under the covers if necessary (within some sandboxed constraints), whilst still extracting the value from the simpler UI model. This is where the industry is leaning towards and where we'll focus this article.
- Pro-code: the traditional route for software development offering the greatest amount of flexibility and control. We're calling this pro-code to make the distinction - although it's not a widely used term. The maturity of this approach means engineering practices, such as Continuous / Continuous Deployment and Automated Testing, have developed over time to provide in the software artefacts produced, zero-downtime deployments, and faster turnaround times.
Most software delivery projects in the industry still typically reside within the pro-code approach- using highly skilled engineering teams with vast experience of producing high quality code to exacting standards, using de facto processes and best-of-breed tooling.
At Kainos, we certainly don't think that the pro-code work will ever disappear, and software development companies could quite easily continue with the "all code" mindset for the foreseeable future.
So why low-code?
There are areas within software development that have become commoditised. Take, for example, a simple CRUD application (Create, Read, Update, Delete), that captures simple user input and stores it in a backend server.
This can be delivered in a traditional way (by re-using code from previous projects and utilising tools that reduce boiler-plate code), but it’s a solved problem. It’s been done thousands of times before. The patterns are there and there isn’t significant learning to be done.
The same solution could be delivered using low-code tools in a much quicker timescale with less moving parts, thus giving teams additional time to concentrate on more complex and valuable problems - meaning clients and users get value quicker and/or can tackle more problems in the same amount of time.
Our focus is on giving the best possible value to our customers that we can, both quickly and cost-effectively; not just during the implementation phase but also through the lifetime of the solution.
Low-code also has advantages in not having to deal with infrastructure; availability, patching-cycles, scaling, security, and support are all functions that are provided by the low-code platform vendors.
But it's not a panacea.
There are places where low-code is the right approach, and there are places where it most definitely isn't. Good engineering is all about choosing the right tool for the job.
What makes Kainos different?
Our approach to low-code development leans heavily on our pro-code experience. We use the same engineering rigour and modern development standards, principles, and practices, with good discipline and supporting tooling to produce low-code applications that are secure, scalable, well-tested, repeatable, and functionally complete.
Broadly speaking, we start by following these principles:
- Use low-code for low complexity, commoditised work
- Employ good engineering practices for managing the products
- Store code snippets (business logic) in an external repository
- Apply pro-code testing practices to instil confidence
- Have a strong build and deployment pipeline with DevOps tools.
We’ll explore these further in more detail throughout this series. In the meantime, if you would like more information on how your business can use the right combination of pro, low and no-code solutions to deliver value rapidly, then please get in touch.