by Striped Giraffe Team
4. June 2024
Time to read: 12 Minutes
Low-Code Falls Short Without Full-Code
The most efficient low-code software development is when full coding is feasible.
Individual software development can be expensive. You need to assemble a qualified team of developers and specific technologies. Then, you must navigate the intricate process of designing, coding, testing, deploying, and maintaining your system. The associated costs and time commitments are substantial, prompting many organizations to seek alternative solutions.
They are increasingly interested in low-code development — a promising avenue for streamlining the software creation process.
Low-code platforms have attracted significant attention, offering a compelling solution for businesses looking to expedite their digital transformation. However, reality often reveals a more nuanced picture.
Companies that opt for low-code development are soon confronted with a major challenge: the growing gap between their customization requirements and the limited capabilities of the platform. What initially looks like the perfect solution to software problems can quickly reach its limits when faced with complex requirements and changing system architectures.
So, what exactly do low-code platform providers promise to entice prospective customers?
The promise
Among the marketing pitches of low-code software development tools, you can frequently encounter the following assertions:
- Accelerated prototyping
- Elimination of the need for software developers
- Faster and easier deployments
- Empowerment of business users to independently craft applications, without IT expertise or reliance on IT teams
- Ability to cater to virtually any application need
Yet, such exaggerated claims often breed significant misconceptions about the true potential of low-code platforms. It is time to demystify these inflated statements and examine the reality behind the hype.
The reality
It is a common misconception that low-code platforms allow you to create an application of any complexity that meets every individual need and requirement. In reality, low-code entails adhering to the vendor-defined concepts for application development, in particular, how to configure a data model, forms, processes, user interface (UI), access rights, and more.
If your requirements deviate from these predetermined concepts, you will encounter limitations that are challenging to overcome. While it is possible to work around these restrictions, it often demands significant effort, even for implementing simple non-standard requirements.
However, it is true that low-code tools make it quick and straightforward to build basic applications with a handful of simple forms, screens, objects, or processes. This ease of use holds true even for those with minimal IT knowledge.
That is why, for many companies, low-code may initially seem like an enticing solution, but it can later turn out to be a trap.
You start with simple requirements and using low-code appears to offer immediate benefits. However, as your application evolves and advanced requirements emerge, you will likely find yourself facing hurdles. Customized features and complex integrations become essential, revealing the limitations of low-code.
In such scenarios, devising workarounds becomes necessary but time-consuming, leading to increased costs and frustrations. Rather than reaping the promised benefits, you find yourself grappling with challenges and an escalating workload — especially if the respective platform uses proprietary technologies and concepts.
That said, it is essential to recognize that low-code is not a magical solution devoid of the need for programmers. Non-developers who dive into low-code development may overlook critical aspects of application design, hindering future scalability and maintainability.
Similarly, low-code does not exempt you from adhering to standard development cycles. While there is a desire to implement changes quickly and deploy them promptly, overlooking proper design, development, and testing cycles can lead to issues down the line.
So, when does low-code succeed, and when does it fall short? Understanding the typical limitations of these platforms is crucial.
Let us show you a concrete example. We have developed an HR solution tailored to our needs. In this process, we identified three phases of low-code application development, each of which requires more sophisticated tools in order to be successful.
Stage 1: Piece of cake
Consider some straightforward processes in your company that could benefit from digitization and automation. These might include tasks such as:
- Collecting data with online forms
- Uploading and organizing document files
- Generating task checklists
- Creating a calendar of events, meetings, etc.
- Preparing and submitting applications or requests
- Creating an approval process
- Assigning and track statuses
- Setting up and sending notifications, alerts or reminders
- Generating standard documents
- Automating data tracking
- Sending automatic confirmations
- Developing a simple workflow
- Creating a ticketing system
- Collecting feedback
- Setting up an online registration
- and many more
Let’s assume that these processes do not fit into any of your existing systems. Moreover, extending your enterprise-level solutions to accommodate these tasks would be prohibitively expensive and complex compared to the potential benefits.
As a result, you decide to create a simple application using an affordable low-code tool like Kissflow or Microsoft Power Apps.
Example case: HR application
- Your company is growing rapidly, requiring you to hire an increasing number of new employees, but you lack a sophisticated HR system. So, you decide to develop a simple application to support the recruitment process.
- Initially, the application should enable you to enter candidate data, upload document files, manage a calendar of all meetings and interviews with candidates, include feedback from all stakeholders, and assign appropriate statuses to candidates.
- The first experience with low-code was fantastic. You managed to set up your process in just a few days and immediately implement it within your organization.
- Encouraged by this success, you decided to incorporate more processes. You began digitizing simple tasks related to onboarding new employees. You added a feature to your application that automatically generates employment documents and assigns specific tasks to the appropriate personnel, such as setting up email accounts or providing access to the intranet and other digital resources/tools. Additionally, you created a checklist of all onboarding tasks to help you track their status.
- Subsequently, you added a similar offboarding process for employees leaving the company.
Stage 2: Here comes the harder part
As your project progresses, the demands placed on your application become more intricate. You are faced with complex requirements including a more complex data model, authorization procedures, significant UI customizations, and the need for asynchronous integration with other systems.
You also want to empower application users to access and edit some information. For this, you have to reengineer your data model and implement row-level security (RLS). This ensures that access to information in the database is controlled by row, so that users are only able to see the data they are authorized for.
While basic low-code platforms may fall short in providing these advanced features, more sophisticated, albeit more costly, tools like Mendix, Pega, or OutSystems offer the necessary capabilities.
Importantly, at this point, you have to start adopting a development approach akin to traditional software development. You can no longer rely solely on drag-and-drop features; instead, thorough planning and adherence to established software development and release cycles become imperative.
Example case: HR application (continued)
- With your core recruitment process in place, you now want your application to automatically create a record in the employee database for each new hire, encompassing their personal data and electronic documents.
- Furthermore, your application should seamlessly synchronize with other systems to automatically create accounts for new hires and grant them appropriate access to company resources (email, intranet, wiki, JIRA, cloud drive, etc.).
- Additionally, you aim to extend your application’s functionality to include the management of external personnel such as freelancers or subcontractors. In your application, you would like to handle their personal profiles, contracts, and access rights in the same way you do with your employees.
- You also want your application to generate various reports based on specific criteria, such as employment type, contract status, salary details, and work hours.
- Finally, you would like to empower every employee to access the system for HR-related tasks, from updating their personal information, requesting official documents, like a salary certificate for a bank loan, to submitting employee applications, such as a request for leave.
Stage 3: Hitting the wall
Asynchronous integration is relatively simple to achieve with most low-code tools. However, things get complicated when you need to display real-time data and allow users to work with it.
This requires synchronous integration, meaning your app must call other systems’ APIs in real-time to access and display data. Most low-code platforms struggle with this level of integration. Typically, they pull data from a back-end system and display it from a local database. But that includes data duplication, which is usually not desirable.
Another major challenge is implementing highly customized user interfaces. Most low-code platforms offer predefined UI templates and components as well as standard screen flow concepts. If your vision deviates from these standards, customization becomes difficult, if not impossible.
Defining automated data retention rules is also tricky. Legal or company policies might require you to erase data after a certain period. Many low-code tools lack the capability to automate this process easily.
Stringent data security requirements can present further complications. If your app handles sensitive data, your IT security team might insist on hosting it on company infrastructure with special encryption or data processing requirements. Many low-code platforms, offered as SaaS solutions, do not support this.
Resolving performance issues add to the complexity. As your low-code system grows, performance can degrade. Since you do not have access to the source code, diagnosing and fixing issues requires vendor assistance. The same applies to bugs and security gaps.
These limitations highlight a critical point: developing complex systems based on individual requirements significantly deviating from the standard can become very difficult or even impossible with low-code platforms. When this happens, the initial advantages of low-code disappear.
Example case: HR application (continued)
- You want all candidate communications to be managed within your HR tool, storing emails, texts, call summaries, and interviews for stakeholder access.
- Your IT security team requires special encryption for sensitive data and all documents.
- You need certain candidate data to be deleted six months after recruitment ends if the candidate is rejected.
- Via a synchronous API, you want to integrate your HR application with a time reporting system to display employee tasks, hours worked, or absences in their profiles.
- Similarly, you want to integrate with the payroll system to review employee salaries, bonuses, deductions, benefits, and taxes.
- In both integrations, the data belongs to other systems and should not be stored in your HR tool. However, you need to browse and present this data in customized tables or charts, requiring significant UI adjustments.
The best of both worlds
Even advanced low-code tools struggle with complex data models and real-time integrations. So, how can you overcome these limitations?
The answer lies in coding. By modifying or replacing the code, you can bypass most restrictions. But, to do this, you need a tool that allows deep code customization. That is where high-end platforms such as A12 come in.
With A12, you can perform typical low-code tasks easily and quickly:
- Model your data
- Design forms for data entry
- Configure data display and search
- Set up application navigation and screen flows
Business analysts can handle these tasks independently. The resulting models can then be passed on to developers for integration into application builds.
When advanced features are needed, developers can:
- Integrate asynchronously or synchronously with third-party applications
- Retrieve real-time data from other sources
- Customize any UI elements or screen flows
- Implement complex business logic
- Adjust the platform’s standard behavior
- Deploy the application on your own infrastructure or any cloud service
Simply put, platforms like A12 offer the best of both worlds. You get all the benefits of low-code, and you can also customize your application extensively with full-code capabilities.
Developers or users can decide whether to use the platform’s standard features or switch to full-code mode. Standard requirements and processes can be modeled in low-code mode, minimizing the need for coding. Custom needs can be addressed by editing or adding new code.
Having access to the code of your application means you can deploy it as you prefer. For instance, you can run it on any public cloud, like AWS.
This gives you full control over your system. If problems arise, you can debug and test the application to identify and fix issues.
Platforms like A12 provide flexibility, control, and the ability to meet any requirement, combining the ease of low-code with the power of full-code development.
Conclusion
Low-code platforms are great for developing simple applications without extensive IT knowledge, but they struggle with complex and non-standard business requirements. They work well for tasks like data collection and basic workflows, but as customization needs grow, their limitations become evident. More advanced low-code tools and professional developers are often needed for sophisticated projects.
The promise of rapid deployment and minimal need for developers is appealing but can lead to misunderstandings. Businesses might initially benefit but face significant hurdles as applications evolve. Platforms like A12 offer flexibility by allowing a switch to full-code mode when necessary, blending ease of use with the power of traditional coding.
Ultimately, low-code should not be seen as a one-size-fits-all solution. For long-term scalability and adaptability, businesses should incorporate coding into low-code projects or choose platforms that allow deep customization. This approach ensures the benefits of low-code while meeting complex business needs.
