What is low-code and why should I care?

In this three part series, I’ll discuss the latest big move in software development and what it means for you and for digital transformation generally.

Part 1 – the Citizen developer


Low-code is a movement in the software industry. It’s name indicates the nature of the change – “low-code” – software created with less programming code than the traditional approach.

Low-code is an alternative to configurable off-the-shelf solutions – they offer options within a tightly controlled capability. For example, with an off-the-shelf accounting package, you might be able to select from a range of taxation types. But if you’re in a jurisdiction not covered by that package, or if your tax laws suddenly change, you’d have to invent workarounds.

Because these off-the-shelf packages are designed to satisfy a market segment generally, they can often restrict innovation and also tend to bind the customer to regular updates to try to keep up with general market changes.

Instead, low-code platforms offer the potential applications designed for you (and potentially by you), without the cost and complexity normally associated with software development based in thousands of lines of programming code.

In theory at least, assuming the platform itself is robust, the less programming code there is, the less can go wrong, development should be faster, less complex and more flexible.

For some low-code platforms, applications can be created using drawing tools to create forms and workflows graphically (a no-code solution). Small amounts of hand-written code are then added where the graphical approach isn’t specific or flexible enough (a low-codesolution).

Other platforms offer basic components which can be configured simply by supplying textual or near natural-language instructions called metadata.

Low-code platforms typically provide mobile device accessibility, security and a suite of features for data import and export. Some platforms go further with built in support for maps, reporting, collaboration, notifications and more.

Some low-code platforms are totally in the cloud – the engine which makes the software work is not directly accessible or deployable on your own servers. Though they might offer a free startup, they attract ongoing usage and access fees. Others, like the Skyve Enterprise Platform are open-source and free to use, with no requirement for ongoing licence or usage fees.


If you haven’t heard about low-code yet, you will. It is a major step forward in the maturity of the software industry.

Low-code is relevant to you because it’s not just about getting software faster or cheaper, but it’s about getting you involved.

Up to now, software has been left to the experts. And while it’s reasonable to expect that technology should require technicians, that approach hasn’t always gone swimmingly – and we’re all aware of spectacular failures – not just where software hasn’t worked (#censusfail) but also where it has worked all too well, in the absence of other types of social, legal and ethical knowledge (#zuckergate).

So if for example, you’d had a hand in designing Facebook, you’d probably have taken more care to ensure your data was secure and private. And if you had a hand in designing other software you use, you’d probably design different features to suit your specific needs. Software is not only a technical endeavour – and “citizens” need to be involved to ensure it is fit for their purpose.


The process of software development has often been too slow to respond to the rising expectations of the techonomy (think economy but tech).

The explosion in the adoption of Microsoft Access in the nineties and noughties was in largely a result of the frustration of non-technicians (citizens), who wanted the benefits of the software revolution without having to wait for centralised IT groups to deliver solutions.

The wide adoption of Access was based on the promise that anyone (citizens) could build a system – using drag-and-drop designers to build forms, reports and queries and organise data.

But with every new button came a few lines of code – a little bit of technical debt. And once you have a hammer, everything looks like a nail. And so the debt built up. That debt consists in the effort required to maintain and replace these systems, also in the opportunity cost from the inefficiencies of poor design decisions and limited technology.

Jump forward 15 years and there are by some estimates more than 300 million Access databases lurking around on office networks (I suspect that’s an underestimate). I know of several organisations with tens of thousands of Access files and applications, representing not only a significant headache for CIOs, but a serious technical risk that critical data isn’t being managed appropriately.

Lesson 1: If you don’t provide the tools people need to do their job, they’ll improvise. We call it innovation now and we love it, but the flip-side is called “shadow IT” – often a serious risk for organisations (though often ignored and unmanaged).

Lesson 2: You need expertise to design and build enterprise scale systems. Engaging the citizens can lead to significant costs (and opportunity costs) down the road.

Lesson 3: If you want ongoing innovation, you need technology that supports continual change – or you’ll be continually changing your technology.

While low-code platforms generally enable rapid development of apps by citizens, it’s less clear whether the promise of the citizen developer has been fully realised, and Forrester forecasts a widening “fork in the road” – between platforms for citizens and techs (Vendor Landscape: A Fork In The Road For Low-Code Development Platforms).

Some analysts suggest that while low-code may allow a citizen developer to create a minimum viable product rapidly, the feedback is that other users often don’t like them. That’s not surprising at one level – there is actually a science to good design after all.


12 years ago, we began down the road of building our own low-code development platform – the Skyve Enterprise Platform – low-code suitable for enterprise scale systems.

Sure, we aim to empower the citizens to be able to manage their data, to automate their own processes, to customise their experience, to collaborate and to give users a really rich suite of capabilities. From lesson 1 – we’re giving citizens the power to innovate and improvise and we’re continually enriching the experience.

But we do this within a platform that automates good interface design and usability. In fact we’ve steered away from a “draw your app” starting point, because we believe this leads users down the wrong track of getting caught up with layout decisions, rather than building capability.

We also suggest layouts generated automatically will be more consistent and usable than may result from ad-hoc design. So we typically leave UI design to the Skyve engine, at least initially.

We’ve also chosen to keep the key design decisions and the technical debt for the techs who have an understanding of some of the wider implications of common decisions when they’re scaled up (lesson 2).

Our approach means low-code can be used to build serious enterprise scale applications. And it’s proven very effective – a state taxation system, software to support transitioning a major hospital, industry engagement systems and the like.

But key to ensuring low-code isn’t just a fad, is to ensure it’s not linked to any specific technology under the hood.

We’ve been continually updating the Skyve platform – not only with new features and inclusions, but with updates to the latest open-source frameworks – meaning that applications built with Skyve are up to date with current technology and capabilities, even if they were built 10 years ago (lesson 3).

Take for example Skyve’s unique platform independent backup – backup from Windows/MS SQL Server and restore to linux/MySQL or the other way, and move to new Operating System and Database options as they come along. This gives us the freedom to change and move with


We figure low-code is here to stay.

It seems hard to justify the risk associated with large amounts of hand-written code once you’ve been exposed to the potential of low-code, especially a platform which supports both enterprise scale development and quick prototypes.

If you’re picking a low-code platform, I’d recommend not getting caught up in a slick form designer, or a promise of bots that can generate thousands of lines of code per second.

Instead, ask yourself whether the platform you’ve chosen locks you in to one provider or one technology.

Also keep in mind your objective – are you building a quick solution for a short-term problem, or will your quick fix lead you to be caught in a situation where you have to keep paying ongoing usage and hosting fees?

And finally, seriously consider exit. How will you exit out of the choice you’ve made? – and how will you transition the data you’ve built up?

Join me for the next instalment of this series, on low-code and the promise of rapid development.

conceptsBen Petito