Aishling Warde

Test automation is an integral part of modern software development, primarily focused on enhancing the efficiency and effectiveness of testing processes. But for some reason, after decades of effort, success is still anything but obvious. I think anyone can mention numerous examples where the expected or hoped-for success did not materialise.

You would expect that after all this time, we should be quite skilled at it. Yet, I believe there are a number of reasons that prevent us from fully harnessing the true power of test automation.

Firstly, there is a vast number of tools available, and the pace at which these tools develop and surpass each other is impressively high. Just keeping up with these changes could be a full-time job. But aside from that, we also need to ensure that we don’t end up using a new tool every few months, which we then have to learn, implement, and manage.

It’s not by chance that I’m focusing on the tools here. This is exactly one of the reasons our success is often jeopardised: an excessive focus on the tools! Test automation encompasses so much more than just having a tool to avoid manual testing, yet training programmes almost always focus heavily on tool training.

Let’s Look Beyond the Tools

I am convinced that the likelihood of success significantly increases when we pay more attention to truly understanding what test automation entails. In test automation, you deal with a broad and diverse landscape, extending beyond just test definition and execution. When we look at the whole picture and include test management, test data management, and results and evaluation, all play an essential role. However, we are often not aware of this.

When we look beyond the tools themselves, an entirely new world opens up: that of the relevant aspects impacting the implementation of test automation. Questions that then arise include:

• Which techniques are we working with and need to be supported?
• How do we optimally integrate the test (automation) process into existing processes?
• What does the organisation itself demand and require from us?
• How does the human factor influence the choices we make?

If we are aware of which questions to ask and how to integrate the answers into our architecture, we increase the likelihood of a successful test automation implementation. Now, the challenge remains… we won’t gain the necessary knowledge if we continue to focus on learning yet another tool.

Let’s Make a Change: Learn About Test Automation!

Fortunately, there are now training programmes available specifically aimed at teaching that knowledge. Certified Test Automation Professional (CTAP) is a good example of this, and I am very enthusiastic about it. The CTAP programme is designed to educate its participants on all critical aspects of test automation.

This training programme focuses on things like:

• Different areas of application for test automation
• Aspects that impact test automation
• Test architecture and tool selection
• The impact of AI on test automation
• Principles and methodologies
• And much more…

It balances important theoretical knowledge with useful practical skills. Armed with that expertise, you will undoubtedly be able to ask the right questions and uncover the necessary answers.

Dutch organisations like the Tax Office (Belastingdienst) and the Social Security Agency (UWV) are already embracing this training and the associated certification, and they are seeing many positive effects. They cite increased quality and a higher level of collaboration around test automation as major advantages. Additionally, it helps to have a common frame of reference and a clear understanding of what the world of test automation entails.

Ready to join the change and significantly increase the chances of success for test automation? Then dive further into the Certified Test Automation Professional programme or sign up for one of our training sessions! More information can be found here – Certified Test Automation Professional CTAP 2.0

Author

BQA are exhibitors in this years’ AutomationSTAR Conference EXPO. Join us in Amsterdam 10-11 November 2025.

Fast releases demand efficient testing – but traditional test automation is often too complicated. TestBench and Robot Framework combine no-code test design with low-code implementation. The result: test automation that is clear, fast, and flexible – without technical barriers.

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.

Would you like to find out more about this topic? Then download our whitepaper now!

Author

Imbus are exhibitors in this years’ AutomationSTAR Conference EXPO. Join us in Amsterdam 10-11 November 2025.