In the journey of digital transformation, the path to modernization could be a challenging one. When faced with technology modernization, dealing with legacy systems such as 5250-based, green screen applications, tightly coupled business logic, monolithic code base structures and limited knowledge of the application architecture, what choice do you have? You take a look at what’s trending in the market. You observe that there is an increase in the spending on low code technology (to the tune of $21.2 billion by 2022). Consequently, you decide to get on the bandwagon.
You choose a low code platform and begin the process of modernizing your applications. Fast forward a few months and you realize that the easy to use, drag-and-drop feature is great to build a prototype but the platform falls short in etching out the intricacies of a serious enterprise application. You also realize that when you want to scale up and build more applications and increase the number of users there is an additional cost. Added to that you have runtime dependency and added cost of deployment on infra of your choice. These among many other challenges edge you towards a reality check and it makes you wonder whether, in the urgency to modernize and be competitive, was the low code platform a right choice?
Every enterprise is keen to ride the low code wave, and in line with the modernization narrative, they should. The challenge arises when low code is adopted without learning about the ‘nuts and bolts’ of the platform and understanding how it fits their requirements. This is when a reality check occurs, when there is a glaring gap between expectations and reality. More often than not, the reality of technology modernization and digital transformation is different from what is expected. It’s a fact that while companies have reportedly spent $1.2 trillion on digital transformation in 2019, analysis indicates that just 1% of these efforts would actually achieve or exceed expectations.
Expectation Vs. Reality. Bridging the Gap When Adopting Low Code
Assume nothing. Know what to expect to mitigate reality checks
Before adopting low code, it is important to take into account the expectations and requirements of different stakeholders. CIOs, CTOs, Application and IT Leaders expect that an investment in a low code platform must speed up time to market of application development and delivery, reduce operational costs, address the skills gap, bridge silos between users, developers and IT teams, ensure scalability, and promote growth. IT teams expect low code platforms to take the pressure off by enabling business-users build their own applications with minimal IT support, thereby giving them the bandwidth to innovate. Developers are a league of their own, and assume that they “tell” the platform what the application should be. Professional development teams expect low code platforms to automate time-consuming and mundane tasks of code generation, so that they can focus on developing application features that will provide differentiation and improve user / customer experience.
Taking into consideration these different expectations, let’s take a look at some of the assumptions that create the gap between expectations and reality, and what can be done to reduce it.
Assumption 1: The platform is built for enterprise-grade application development
- Expectation – You assume or expect that all low code platforms are designed for professional developers. That the low code platform has the technology stack and architecture to help development teams build complex, enterprise-grade applications.
- Reality – Not all low code platforms support professional application development. Most platforms are designed for citizen developers or business users who typically build prototype or shadow IT apps using template-driven UI.
- What could be done to reduce the gap – Take into consideration the technology stack offered and the platform architecture to understand if it can support serious, enterprise-grade application development.
Assumption 2: Low code will replace coding
- Expectation – With the promise of a WYSIWYG development environment and visual drag-and-drop application development, you expect that by using a low code platform it will replace manual coding.
- Reality – Complex, enterprise grade applications usually have intricate business logic. Building a rich application often requires developers to go native and there is a certain degree of manual coding needed to give attention to details of the application.
- What could be done to reduce the gap – Low code application is not about replacing manual coding it is about optimizing the time of developers. When adopting a low code platform, you need to maintain a balance between low code and high code. In this way you can shorten the time frame of time-intensive tasks such as testing and allow developers to focus on other intricacies of application development.
Assumption 3: The platform generates quality code and testing is not required
- Expectation – You assume that as the code is auto-generated and not manual there would be a lesser chance of errors. You may also expect that the low code platform generates quality code and has built in security and testing features therefore applications built would function successfully.
- Reality – Some applications built using low code fail to perform, owing to several reasons, from coding or business logic errors, integration issues, to security threats.
- What could be done to reduce the gap – While the promise of low code is to build applications that would be functional and secure, you need to have a testing strategy in place. You need to ensure the platform has features across the development lifecycle to test applications for functionality and security. This would reduce the level of risk associated with implementation failures and security threats.
Assumption 4: The platform is scalable and supports increasing growth
- Expectation – You assume that you can easily scale up to build unlimited number of apps and support an increasing number of users at no additional costs.
- Reality – When the time comes to build more applications, increase the number of users, or move to another development environment, you realize many low code platforms have an additional cost involved and do not have the capabilities for scaling up.
- What could be done to reduce the gap – It is important to assess if the platform provides dev-time and run-time scalability and consider if the licensing model of the low code platform fits your scalability needs. While there are platforms where you need to pay to increase the number of users or applications you can develop, there are pricing models where you can choose to pay per developer. Therefore, identify your scalability needs first to make sure the licensing model is suitable.
Assumption 5: You are not locked in to the platform and can customize applications after migration
- Expectation – In a situation when you need to migrate to another platform, you assume that the low-code provider can provide the assurance you will be able to generate the code and recompile applications.
- Reality – While your application may run, do you know if you can make changes to the code or are you locked in to the platform? Is the code readable to customize applications? In situations of migration, generated code is usually algorithmically accurate, although the code is not readable by humans, making it difficult for developers to make any meaningful code modifications required.
- What could be done to reduce the gap – Given the significant impact of applications on operations, anyone using a low code platform must check and test the code generated. Make sure the code generated is syntax-agnostic and that the code is readable and customizable which are important factors in long-term maintenance of applications.
Assumption 6: There is no runtime dependency and you are free to deploy on infra of your choice without separate cost for deployment.
- Expectation – You expect end-to-end freedom in using the platform, from application development to deployment. You assume there is no runtime dependence and that you can deploy applications on infrastructure of choice, from containers, virtual machines to on-premise infrastructure.
- Reality – While application development is free, many low code platforms have a separate cost for deployment and use in-house runtime engines. The applications built on the platform are deployed on select clouds and in their environments, making it a challenge to gain ownership of code and rebuild applications.
- What could be done to reduce the gap – To minimize operational cost, ensure the low code platform has an open-source runtime engine, one that gives access to the runtime libraries used and allows developers to customize applications without being locked-in to the platform.
Assumption 7: Underestimating the complexity of managing APIs during integration
- Expectation – During the integration process, you expect the platform to provide developers with a visual approach to embed data elements directly into the application, connect to data sources, and even allow them to configure business logic and design data models inside the application.
- Reality – This would probably work fine if your application is integrating with only a few other systems. The challenge arises, when you have to integrate more than a dozen systems and manage APIs.
- What could be done to reduce the gap – When you have to integrate several systems, it is best not to underestimate the complexity in managing APIs. What you need to understand is the type of documentation that the low code provider offers and how it would enable managing APIs in the long run.
Modernization, as a part of digital transformation, is an intensive affair. Through 2021, Gartner predicts that digital transformation projects, by large and traditional enterprises, will take twice as long and at double the cost than anticipated. On the other hand, smaller and agile enterprises will be more successful in implanting modernization and digital transformation initiatives. Regardless of this factual prediction, enterprises, large and small alike, can still gain leverage by adopting emerging technology solutions, such as low code. Solutions that constantly evolve, adapt to the challenges of technology modernization and make the journey of digital transformation smooth sailing and successful.