For any organisations that have been using a form of low-code technology for the past decade or more, predictions that 2021 is ‘the year of low-code’ might seem somewhat vacuous. However, the reality is that the low-code platforms that have been around for decades are very different beasts to those hitting the market today. The technology has undergone quite a journey since its inception in the early 2000s, having developed through three different generations.
The first two generations still have their uses today, but we’re seeing the emergence of a ‘stack’ approach to low code, ranging from developer tools to simple workflow builders – two very opposite ends of the scale. Yet, the low-code trend is still seeing change as well as growth.
Gartner’s 2021 impact radar predicted low-code to be the only emerging technology product to have immediate and very high impact in enterprises. In fact, the analyst predicts that, by 2025, 70% of new applications developed by enterprises will use low-code or no-code technologies – up from less than 25% in 2020 – and 50% of midsize to large enterprises will have adopted LCAP as one of their strategic platforms.
But why is the technology just coming to the fore now? Well, largely because the third generation of low-code is all about bringing the operational and technical sides of the business together. To understand the significance of this, it’s important we go back to the beginning.
Jonathan Wiener is CRO at Aurachain
First generation
The first generation of low-code tools were essentially built for professional developers – to make their job quicker and easier by providing them with the capability to incrementally improve application development efficiency. And once developers had learnt how to use them, they were largely successful. They had the crucial governance and controls required for enterprise grade applications built-in, covering development, testing, production, licensing, and data. The tools used long-standing development methodologies, meaning developers understood them and could use them to build many different types of applications.
However, this was also their downfall – certainly from a business perspective. First generation low-code wasn’t intuitive for line of business stakeholders, which meant their involvement in the development process was typically limited to providing requirements through a traditional back-and-forth translation processes. This created a single-threaded delivery model whereby the developers would need to understand the requirements from the business, create a technical specification to go to blueprinting, to budgets, to development, to feedback, and then back to be developed further, all the way through to systems integration, UAT, go live, and then change requests, starting the process all over again. At the same time, it was difficult for businesses to understand what was happening ‘behind the scenes’, so they had no frame of reference as to how the application ‘behaved’ in relation to their original business requirements. They could request different rules or logic, or for objects to be added, but they weren’t able to see or understand what they were working with. This process was laborious and created many breaks in the development cycle.
Second generation
With second generation low-code came the term ‘the citizen developer’. This originated around four years ago and essentially represented a revolution. On the whole, people had become more tech savvy and accustomed to using apps in their everyday lives. Meanwhile, businesses no longer wanted to rely on or wait for IT to introduce or change application functionality. Rather, they wanted to liberate their own ability to rapidly automate operational elements of their specific functions for immediate business value. These factors, combined with a developer skills shortage and increasing demand for digital transformation, caused the perfect storm and an evident gap in the market for IT vendors to fill; launching a new era where people with no technical background whatsoever could build simple software applications.
Citizen developer tools targeted ‘quick automation for the workgroup’; they could be used to create low to mid-complexity applications for between 12-24 users within a specific group in an organisation to fulfil a specific purpose. Whoever understood the subject matter within the business could create it and make changes quickly.
Yet, since these tools were largely built for small workgroups, they almost always lacked the necessary architecture framework to allow for scale and interoperability, limiting their utility for large user communities, complex technology landscapes, and enterprise scale deployments. In these instances, organisations either hit hard barriers in what could be done or required significant intervention from a variety of technical disciplines to try to extend what wasn’t native to the tool itself.
Second generation low-code also created a new set of challenges for the enterprise and IT personnel, who were tasked with ensuring governance over a variety of areas surrounding application deployment and business utility. Critical capabilities such as multiple environment availability for staging, access rights, data for technical and business audits, critical security features, license control, on-premise deployment options, (in summary, many of the critical strengths of first generation toolsets) were frequently missing from their native set of functionalities. With this in mind, it comes as no surprise that scores of IT personnel are still wary of the introduction of these toolsets into their organisations.
Nevertheless, the first two generations of low code still co-exist to serve very different purposes. Generation one is an iteration of what developers had always done – coding but with built-in accelerators, governance, and publishing frameworks. Generation two represented a step-change, freeing the business to automate many simple applications quickly for tactical operational advantage and productivity. They serve two extremes, but in a world increasingly driven by rapid digital transformation, both have advantages and benefits to the client.
Third generation
The future is one that creates the best of both worlds. One that gives the enterprise the ability to build simple-to-high complexity applications, that can scale from dozens to thousands of users, and hundreds to hundreds of thousands of transactions. One that has all the built-in controls and functionalities required for enterprise governance, but at the same time fosters a more collaborative environment, where subject matter experts can input into the building of a software application, understand what is being built as it’s being built, and contribute in a way that is intuitive to their specific expertise. Depending on the preferences of the client, this can even include having the business stakeholder work on elements of the build consistent with their subject matter expertise (automation flows, data models, UI design, rules configuration), while keeping the more technical aspects (integrations, access control, staging of environments, technical audits) within the domain of the technical subject matter experts.
Enterprises need digital applications to be created quickly and easily adaptable to fit their constantly changing needs, and the pandemic has only reinforced how crucial this is. Businesses needed to evolve at pace and were looking for faster, lower-cost and more agile ways of doing things. Their teams, goals, and processes had to change quickly, and so too did their technology stacks and critical business applications.
This is why we’re seeing such a boom in third-generation low-code. It removes the business and IT fiefdoms, bringing the business and technical organisations together to collaborate and achieve quick time to value. Technical and business teams within enterprises can work simultaneously for a common purpose within a platform that’s still being controlled as a single platform. It’s enterprise grade with all the correct built-in governance, is intuitive to all users, and can be scaled rapidly, handling a smooth evolution from departmental to complex enterprise apps. It ticks all the boxes for the time-poor, fast-moving, multi-faceted, ever-scaling enterprises today.
