2 minute read

For many code-first developers, the initial inclination is to use familiar code-first testing tools like Playwright when working with low-code solutions. While this approach might seem logical, it can present several challenges, particularly in terms of scalability and efficiency.

Scale Issues and Resource Constraints

Code-first testing tools often require specialized skills and knowledge, which can be in relatively short supply. This scarcity of resources can create bottlenecks in the testing process, as there may not be enough skilled testers available to meet the demands of large-scale projects. This limitation can slow down the development cycle and delay the release of new features and updates.

Bottleneck in the Testing Process

Relying solely on code-first testing tools can create a bottleneck in the testing process. As low-code solutions are designed to accelerate development, the testing phase should ideally keep pace with this rapid development cycle. However, code-first testing tools can be time-consuming to set up and maintain, leading to delays and inefficiencies.

Examples from Customers

We have seen examples from customers where the time required to build tests using code-first tools exceeds the time taken to create the low-code application itself. This discrepancy undermines the promise of rapid results that low-code solutions are designed to deliver. In such cases, the benefits of low-code development are negated by the slow and cumbersome testing process.

The Need for Low-Code Testing Tools

To address these challenges, it is essential to leverage low-code testing tools that align with the principles of low-code development. These tools are designed to be user-friendly, require minimal coding skills, and can be quickly integrated into the development workflow. By using low-code testing tools, organizations can:

  • Accelerate Testing: Low-code testing tools enable faster test creation and execution, keeping pace with the rapid development cycles of low-code solutions.
  • Reduce Bottlenecks: By minimizing the reliance on specialized code-first testers, low-code testing tools help eliminate bottlenecks in the testing process.
  • Enhance Collaboration: Low-code testing tools facilitate collaboration between developers, testers, and business users, ensuring that all stakeholders are involved in the testing process.
  • Maintain Quality: Despite the speed of development, low-code testing tools ensure that applications are thoroughly tested and meet high standards of quality and reliability.

Keep It Simple Principle

The “Keep it simple” principle is crucial in automated testing. By leveraging common components and pre-built assets provided by the Power Platform Engineering team, developers can avoid reinventing the wheel. These levels of abstraction for common patterns simplify the testing process and ensure consistency across applications. This approach not only saves time but also leverages the expertise of the engineering team to create robust and reliable tests.

No Cliffs Extensibility Model

The no cliffs extensibility model further enhances the testing process by allowing seamless integration of code-first contributions and extensions. This model ensures that there are no abrupt transitions or “cliffs” when moving between low-code and code-first approaches. It creates a win-win situation where code-first developers can contribute their expertise to low-code solutions, and low-code developers can benefit from the advanced capabilities of code-first tools.

Conclusion

While code-first testing tools have their place, they may not be the best fit for low-code solutions. The scale issues, resource constraints, and potential bottlenecks they introduce can limit the effectiveness of low-code development. By adopting low-code testing tools and following the “Keep it simple” principle, organizations can overcome these challenges, ensuring that their low-code solutions are tested efficiently and effectively. The no cliffs extensibility model further enhances this approach, allowing for seamless integration of code-first contributions and creating a collaborative and productive development environment.