Leave Complexity Behind: No-Code Test Automation with Low-Code integration via Robot Framework and TestBench

Challenges in Test Automation

Agile software development demands high quality and fast delivery cycles. Test automation is essential for this – but comes with two typical hurdles:

1. Separated know-how: QA testers know the requirements, technical automation engineers know how to implement them. However, the other knowledge is often missing.
2. Delays due to disruptions in the processes: Changes to automated tests often require successive work steps between the QA specialist and technical teams – which takes time.

Goal: Specification = Automation

The solution: An approach in which tests are automated directly during specification – without prior technical knowledge on the QA specialist side or detailed domain knowledge on the technical side.

This article shows how a combined no-code/low-code approach with TestBench and the Robot Framework closes precisely this gap.

 

Expertise and Technology – Thought of Separately, Strong Together

The idea: Professional test design and technical automation are created in specialised tools – TestBench for the specification, Robot Framework for the execution.

Both tools are based on the principle of Keyword-Driven Testing and exchange test data and structures via defined interfaces. This enables a clean separation – and efficient interaction at the same time.

Keyword-Driven Testing with TestBench

With the test design editor in TestBench, test cases can be put together using drag-and-drop from reusable steps, the so-called keywords – without any programming knowledge. Test data is defined as parameters or in data tables and clearly managed.

The advantages:

• Clarity: Each keyword stands for an action and generates its own test result.
• Reusability: Keywords can be used multiple times and maintained centrally.
• Efficiency: Changes only affect individual keywords – not the entire test case.

Example:

A vehicle consisting of a basic model, special model and several accessories is to be configured. The test sequence required for this is mapped using three keywords:

 

 

The parameter list of the test sequence maps the data interface of the test sequence:

 

 

The values of the test sequence parameters are stored in data types and can be assigned values in the associated data table:

 

 

Each line of this table represents a run of the test sequence with the values from the line, i.e. it represents a specific test case. The specifications of the test cases are created in TestBench, which serve as a template for the implementation of the test automation in the Robot Framework. TestBench therefore represents the no-code part of the solution.

Keyword-Driven Testing with Robot Framework

The Robot Framework also relies on the Keyword Driven approach, in which test steps are described by reusable commands, the keywords. The advantage: The tests are structured in tabular form, are easy to read and can also be understood by non-technicians. However, basic programming knowledge is helpful for implementing technical keywords. Robot Framework comes with many standard libraries (e.g. BuiltIn, OperatingSystem, Collections) and can be extended by hundreds of specialised libraries – for example for web tests with Selenium or Browser Library, SAP with Robosapiens, databases, APIs and much more. Customised libraries only need to be developed for very specific requirements. The tests themselves are usually created in VS Code or IntelliJ IDEA – supplemented by plugins such as RobotCode, which enable syntax highlighting, code completion and test execution directly in the IDE.

Example: Vehicle configuration by keywords

A simple test case, e.g. for configuring a vehicle, could look like this:

 

 

In this illustration, each step of the test procedure is described using a single keyword – such as Select Base Model, Select Special Model or Select Accessory. Each keyword takes on a clearly defined task – and can be reused several times.

The technical realisation takes place on several levels: A keyword such as Select Base Model calls up other keywords internally – for example to find UI elements, wait for visibility and make a selection.

 

Transparency at every level: the Robot Framework protocol

A major advantage of the Robot Framework is the detailed logging of each test step – including all keywords called, times, success or error messages:

 

 

As can be seen in the example, the Robot Framework not only documents the process of the keyword select base model but also shows all internal steps – from the mouse click to the selection of the correct option. Errors can therefore be analysed down to the lowest level.

 

Technology that adapts – and integrates

Thanks to the large selection of libraries, almost all technologies can be tested with Robot Framework – web, mobile, desktop, databases, APIs, SAP, etc. Different libraries can even be combined within a test case, enabling flexible end-to-end scenarios: from web browser to SAP to mobile app – and back again.

In combination with TestBench’s no-code design, this results in a consistent, efficient automation approach:
QA testers specify – technology implements. Fast, legible and robust.

 

Test Design Meets Automation – Seamlessly Synchronised

The test cases specified in TestBench are transferred directly to the Robot Framework – where they are implemented with technical keywords. Conversely, already realised keywords from Robot Framework can be transferred back into TestBench and used for new tests.

The speciality:
Top-down and bottom-up work simultaneously.
QA testers create scenarios, technical teams develop the appropriate keywords. Everything remains synchronised via a dedicated TestBench extension for Robot Framework – without media discontinuity or loss of time.

TestBench acts as a leading system: it generates test cases, expects ready-made keywords – and controls the execution. The test data is also transferred directly, which does not require any separate data logic on the technical side.

Result: Specification = Automation.

Advantages of the No-Code/Low-Code Combination

The integrated solution consisting of TestBench and Robot Framework offers numerous advantages:

• Simple test design: Users with domain knowhow create tests without detailed technical knowledge.
• Centralised keyword management: Domain specific and technical keywords are clearly separated – but centrally available.
• Efficient collaboration: Clearly defined responsibilities, seamless exchange.
• High maintainability: Keywords can be maintained with pinpoint accuracy, changes are implemented quickly.
• Parallel working: Specification and implementation take place simultaneously – without dependencies.
• Future-proof: The architecture remains flexible and expandable – especially in the rapidly developing technology sector.

Conclusion: Test automation that adapts – not the other way round

The combination of no-code test design with low-code automation elegantly solves the typical challenges in test automation:

• Domain specialists and technical teams work together efficiently.
• Automated tests are created at an early stage – and adapt with flexibility.
• The solution scales – from small scenarios to large test suites.

Compared to pure no-code solutions, the approach is significantly more flexible, sustainable and technically robust – making it a future-proof choice for professional test automation.

 

Request Whitepaper now!