- Log in to post comments
Prototope or reimplement a specific part of the application using no code or low code technologies
Low-code and no-code platforms (LNNC) are development environments that allow users to create applications using visual tools, pre-built components, and configuration rather than traditional programming. No-code targets business users with completely visual interfaces, while low-code offers additional extensibility for developers who need to add custom logic. These approaches speed up delivery and reduce complexity, making them relevant in software-modernization programs where legacy systems have to evolve with a short development cycle approach.
In modernization, LCNC tools significantly improve productivity and enable teams to focus on business outcomes instead of dealing with outdated technologies. They allow rapid redesign of user interfaces for legacy applications, replacing old screens with modern web or mobile experiences. They are also effective for building workflow-based automation, streamlining processes that were previously manual or tightly coupled to monolithic systems. By giving both IT and business users the ability to prototype and iterate quickly, LCNC becomes a catalyst for modernization, complementing API enablement, UI refactoring, and process digitization initiatives.
Typicall supported tasks are the following:
- Choosing the Right Tools: selecting the right tools requires navigating a vast landscape of options, from commercial solutions to open-source alternatives. This involves a rigorous evaluation based on criteria such as ease of use, customizability, integration, deployment, security, long-term viability, and cost.
- Understanding the Domain: it is essential to understand the data models, workflows, and user interfaces, as well as how they interact. A Domain-Driven Design approach helps establish a shared vocabulary, structure the domain, and divide the system into coherent bounded contexts.
- Integration into the Modernization Process: integrating tools and models must be part of a broader modernization strategy. This includes validating the architecture in terms of functionality, performance, and security, as well as setting up testing, version tracking, and integration with other modules.
- Coupling with AI: AI can play a dual role: assisting in model generation to accelerate design, and serving as an integration target through functional AI modules. This coupling enhances system capabilities while streamlining certain modeling tasks.
What is the typical effort for this activity ?
The effort depends on the scenario (prototyping vs full development), the available input (running system, spec, code,...). The effort can be estimated using traditional effort estimation techniques with a speed up factor from 3 to 8 for UI and 4 to 10 for workflows. The effort will be more accurately estimated after the Diagnosis during the Planning phase.
What are the possible dependencies with other activities ?
Low Code No Code relies on a good understanding of how the application supports the business and typically captures models from the company data, workflow. It is recommanded to have those model available, e.g through a domain model. This can be part of existing documentation identified in the Diagnosis part, capture in part in a 4+1 architecture model (logic view, use case view) and/or detailled in this activity through the proposed Domain-Driven Design approach.
What expertise is required to achieve this activity ?
Low code highly reduce the need of a coding expertise to specific tasks to tune the behaviour of component while No Code requires no coding expertise, meaning some business customers can be involved in some tasks, e.g. redesigning a User Interface.
Is this activity optional, recommended or mandatory?
Optional, it depends on the kind of system and of the modernization constraints, and strategy adopted.
Is there a recommended methodology to support this activity ?
We recommand to use Domain-Driven Design method or another similar method helping to capture domain models which directly feed low/no coding activities.
What is the recommended tooling for this activity ?
The spectrum of tool is very large and evolving, tool selection is part of the activity and of the proposed support.
What are the benefits of adopting a Low Code/No Code approach ?
- Productivity / Efficiency: business focus, component libraries: Low-code/no-code significantly boosts productivity by allowing teams to focus on business logic through ready-to-use components, visual models, and pre-integrated connectors. Teams assemble rather than code, speeding up delivery and reducing errors.
but be aware of customization limits, as highly specific or complex requirements may still require traditional development. - Cost Reduction: time, resources, maintenance: by reducing the amount of code to write and maintain, LCNC lowers development effort, the need for specialized skills, and long-term maintenance costs. Applications evolve more easily, with less technical debt.
but watch out for licensing models, which maybe usage- or user-based and can become costly at scale. - Agility / Flexibility: rapid iterations: Low-code/no-code platforms facilitate short cycles and rapid prototyping, allowing continuous validation of requirements with the client. Adjustments can be made visually, reducing the time from idea to production.
This iterative approach ensures ongoing alignment between business and IT teams. - Accessibility for non-experts: LCNC broadens the pool of contributors, enabling non-technical users to participate directly in design or process automation.
It also allows client teams to be actively involved in building and evolving the solution.
What are the limitations related to a Low Code/No Code approach ?
- Lack of software engineering control on architecture, integration, testability, versioning : LCNC platforms often hide architectural details, making system design implicit and harder to optimize. Integration with existing systems, automated testing, and version control can be limited, and collaborative development may be constrained by platform-specific tools.
- Vendor lock-in: using a specific LCNC platform can create dependency on the vendor’s cloud services, APIs, and development environment. Access to underlying code or migration to another platform may be restricted, making future portability costly or complex.
- Maintenance and platform sustainability: long-term maintenance depends on the vendor’s roadmap and platform updates. If the platform becomes obsolete or is discontinued, applications may require significant effort to migrate or redevelop, introducing risk to the project’s longevity.
- Customization and performance limits: LCNC excels for standard business logic, workflows, or UI, but highly specific features or performance-critical functions may be difficult or impossible to implement. Developers may hit constraints in execution speed, resource usage, or extensibility.
- Security: applications built on LCNC inherit the security of the platform and its prebuilt components. Vulnerabilities in the platform, insufficient configuration options, or third-party connectors can expose risks, requiring careful assessment and ongoing monitoring.