EXPO

Sep 08 2025

Stop Tool Training, Start to Learn Test Automation!

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

Frank van der Kuur

Frank embarked on his IT journey early in life, with a significant portion of his career devoted to the field of testing. Throughout this time, he has supported various organisations in improving the quality of their products. By bridging the gap between process and technology, he strives to enhance the efficiency of testing efforts.

Alongside his role as a practical consultant, Frank is also an enthusiastic trainer. He takes pleasure in helping his peers improve through training on testing tools, the testing process, or on-the-job coaching.

BQA were exhibitors at AutomationSTAR Conference EXPO 2025. Join us in Antwerp 4-5th November 2026.

Sep 03 2025

Test Gap Analysis: Reveal Untested Changes

In long-lived software, the majority of errors originate in areas of the code that were recently modified. Even with systematic testing processes, a significant portion of such changes often gets shipped to production entirely untested, leading to a much higher probability of field errors. Test Gap Analysis (TGA) is designed to identify code changes that have not been tested, enabling you to systematically reduce this risk.

Scientific background

The efficacy of TGA is supported by scientific studies. One such study on a business information system comprising approximately 340,000 lines of C# code, conducted over 14 months, revealed that about half of all code changes went into production untested, even with a systematically planned and executed test process. Critically, the error probability in this changed, untested code was five times higher than in unchanged code (and also higher than in changed and tested code).

This research, along with comparable analyses conducted in various systems, programming languages, and companies, underscores the challenge of reliably testing changed code in large systems. The core problem is not a lack of tester discipline or effort, but rather the inherent difficulty in identifying all relevant changes without appropriate analytical tools.

How does TGA work?

TGA integrates both static and dynamic analyses to reveal untested code changes. The process involves several key steps:

Static Analysis: TGA begins by comparing the current source code of the system under test with the source code at a baseline, e.g., the last release. This identifies newly developed or modified code. The analysis filters out refactorings (e.g., changes in documentation, renaming of methods or code reorganization), which do not alter system behavior, thereby focusing attention on changes that could introduce errors.
Dynamic Analysis: Concurrently, TGA collects test coverage data from all executed tests, including both automated and manual test cases. This provides information on which code has been executed during testing.
Combination and Visualization: The results from both analyses are then combined to highlight the “Test Gaps” – those code areas that were changed or newly implemented but were not executed during testing. These results are typically visualized using treemaps, where rectangles represent methods or functions (sized proportionally to the amount of code inside them).

On these treemaps:

Gray represents methods that have not been changed since the last release.
Green indicates methods that were changed (or newly written) and were executed during testing.
Orange (and red) signifies methods that were changed (or newly written) but were not executed in any test, highlighting the critical “gaps” where most field errors are likely to occur.

Impact

TGA is highly effective when applied continuously, e.g., to provide feedback to developers on pull/merge requests, to product owners on tickets, or the test managers on dedicated dashboards – enabling informed decisions about additional testing needs. It significantly reduces the amount of untested changes that get shipped, and has shown to reduce field errors by 50%.

Learn more about TGA and other test optimizations in our free online deep dives!

Author

Dr. Sven Amann

Sven is developer and software-quality consultant at CQSE GmbH. He studied computer science at TU Darmstadt and PUC de Rio de Janeiro and did his PhD in software engineering at TU Darmstadt. Sven is a requested (keynote) speaker on software quality topics at conferences, meetups, companies and universities around the world, drawing inspiration from his vast project experience working with CQSE’s many customers across all industries.

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

Sep 01 2025

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

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

Dierk Engelhardt

Dierk Engelhardt is TestBench product manager at imbus AG. With his many years of experience, he advises and supports customers in the introduction and customized integration of tools into the software development process. He also advises on setting up agile teams and integrating testing into the agile context.“

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

Aug 20 2025

Discover Key Insights with The World Quality Report 2024-25

The latest World Quality Report is here, and it continues to be the go-to source for organizations seeking to stay informed in quality engineering and software testing. It offers valuable insights into the latest trends and developments and testing practices. As digital transformation accelerates across industries, this year’s edition presents critical findings on how businesses are adapting their quality strategies to meet new challenges, especially in an era dominated by emerging technologies like generative AI (Gen AI).

A significant aspect of this year’s edition is the exploration of how Gen AI is being leveraged to revolutionize QA and testing. As organizations increasingly adopt AI-powered tools to automate testing processes and generate predictive insights, the report examines how these technologies are improving efficiency, coverage, and accuracy in testing environments. Readers can learn about the ways AI is helping companies reduce manual intervention, accelerate release cycles, and ensure higher-quality software. The report also addresses the challenges of implementing AI-driven testing, providing guidance on how to overcome barriers to adoption.

68% of organizations report investing in AI solutions, and the technology has become a critical component of the quality transformation agenda. Gen AI is introducing unprecedented efficiencies in software testing and quality assurance (QA), helping organizations streamline operations, reduce manual intervention, and improve the accuracy and coverage of testing. The ability of Gen AI to create test cases and extract test data poses to significantly reduce the workload of quality engineers and testers.

In addition to overall trends, the World Quality Report delves into sector-specific insights and provides a detailed analysis for individual industries such as automotive, retail, energy, financial services, healthcare, manufacturing, and telecommunications. Industry leaders can how their peers are navigating unique challenges within their sectors. For instance, the report highlights how the banking industry is focusing on security and compliance in QA, while the retail sector is prioritizing the customer experience in its testing efforts. By offering a granular view of quality engineering in different industries, the report provides tailored recommendations for businesses to enhance their testing capabilities.

Whether you are a quality engineer, manual tester, business analyst, or CIO, the World Quality Report 2024-2025 is an essential resource for understanding the latest innovations in quality assurance and testing. You will see both high-level trends and industry-specific insights, the report equips readers with the knowledge on quality strategies, emerging best practices, and how to navigate the complexities of current software development. Explore The World Quality Report soon and discover how you can drive your organization’s quality transformation agenda forward.

Author

Olivier Félis

Olivier is a seasoned software testing and quality assurance professional with over 20 years of experience. Currently, he is a Senior Solutions Consultant and Practice Lead for the ALM solution at OpenText. Olivier has a strong background in managing complex test environments and driving innovation in testing methodologies within an integration company. He has led numerous large-scale projects in various industries including pharmaceutical, finance, and hospitality. For the past 3 years, Olivier has been involved in exploring new technologies and innovation to improve and facilitate software reliability and performance

Opentext were exhibitors at AutomationSTAR Conference EXPO 2025. Join us in Antwerp 4-5th November 2026.

Sep 25 2024

Autonomous Test Generation: Revolutionizing Software Testing Through AI-Powered Approaches

The rapid growth in software delivery as a solution for all business needs for organizations has intensified the demand for efficient and comprehensive software testing processes. Ensuring the quality, reliability, and security of software products is of paramount importance as they become increasingly integrated into various aspects of our lives. Traditional software testing methods such as manual testing and automated test scripting, can no longer keep up with the responsibility to identify and rectify defects that make the delivered software ‘defect-free’. In addition to be viewed as inhibitors of fast-paced delivery,  they are viewed as high cost activities.

The recent advancements in artificial intelligence (AI) and machine learning (ML) technologies have given rise to a new paradigm in software testing, known as Autonomous Test Generation (ATG). This approach leverages advanced algorithms and techniques to automatically generate relevant test cases, thereby reducing human intervention and enhancing the overall testing process.  This article is the beginning of a series related to Katalon’s implementation of autonomous test generation, where we will explore the different types of autonomous test generation and their benefits and limitations for the real-world Quality Engineers embedded in the teams of tomorrow. Our goal is to provide you with the knowledge and understanding necessary to make informed decisions about applying autonomous test generation solutions in your software testing process.

Autonomous Test Generation – Definition and Key Concepts

Autonomous test generation refers to the process of automatically identifying, creating and executing test cases for a software application, with minimal human intervention. This approach leverages AI and ML techniques to generate test cases that effectively identify feature defects, vulnerabilities, and user experience issues in software products.

The Role of AI and ML in Autonomous Test Generation

AI and ML technologies enable the analysis of large amounts of data associated with the usage patterns, and applied data characteristics during interactions to predict and generate a suite of evolving test scenarios necessary for maximum confidence of the application. By applying these algorithms, ATG can:

Generate test cases that cover a strategic, data-centric range of scenarios.

Adapt to evolving software requirements and deployed codebases.

Optimize test cases based on historical data and prior outcomes.

Confidently predict and generate new tests based on user observations.

How does it compare to traditional methods?

Compared to traditional manual and automated testing methods, ATG offers several advantages:

Increased Confidence on system behaviors: ATG exhaustively tests different scenarios and edge cases, identifying potential bugs and errors, and providing more comprehensive test coverage.

Efficiency in test creation: AI-powered test generation can quickly create test cases, reducing the time and effort required for testing.

Effectiveness of workflow scenarios covered: Autonomous test generation can identify potential defects and vulnerabilities that might be missed by manual or scripted automated testing.

Scalability in test coverage: The AI-driven approach can easily adapt to large and complex software systems, making it suitable for a wide range of applications and industries.

Continuous adaptation to evolving usage patterns: Autonomous test generation can learn from testing results and adapt its strategies, leading to better test coverage and defect detection over time.

Benefits of using autonomous test generation in software testing

While manual testing remains an indispensable aspect of software development, its limitations can constrain the optimization of software quality. Autonomous test generation emerges as a groundbreaking solution, mitigating these challenges by automating the creation of test cases. Bringing an array of valuable advantages, autonomous test generation enhances time and cost efficiency, delivers extensive test coverage, and promotes seamless continuous testing and integration, thereby revolutionizing the software testing process.

Time and cost efficiency

By automating the process, developers can allocate their time to more value-added tasks, such as designing and implementing new features. Furthermore, the accelerated testing process reduces overall project costs by minimizing the need for human intervention and decreasing the likelihood of costly delays due to undetected issues.

Comprehensive and accurate test coverage

One of the most significant advantages of autonomous test generation is its ability to create a wide variety of test cases that account for a multitude of scenarios. This ensures more comprehensive test coverage compared to manual methods, reducing the likelihood of undiscovered defects or vulnerabilities in the software. Comprehensive test coverage is crucial for delivering high-quality software, as it increases the chances of identifying potential issues before they become critical.

Continuous testing and integration for DevOps  

ATG enables continuous testing and integration, which is essential for modern software development methodologies like Agile and DevOps. With continuous testing, developers can identify and fix issues early in the development cycle, leading to faster delivery of high-quality software. This proactive approach to software testing also reduces the risk of costly post-release defects and contributes to an overall improvement in software quality.

Maximizing Software Quality Through Autonomous Test Generation

The true potential of ATG lies in its ability to not only streamline the software testing process but also elevate the overall quality of the final product. Autonomous test generation can lead to higher quality software by making an impact on defect detection, adaptability, and increased confidence in software releases.

Increased awareness of defects 

By employing AI algorithms, ATG can generate a diverse range of test cases that account for complex scenarios. This breadth of test coverage increases the chances of continuously detecting defects that manual testing methods may overlook. Early identification and resolution of potential issues are crucial for maintaining high-quality standards in software development, making autonomous test generation an invaluable tool in the pursuit of high-quality digital experiences.

Adaptability and scalability for evolving solutions

One of the most significant advantages of autonomous test generation is its ability to adapt seamlessly to changes in software requirements or codebase updates. This adaptability ensures that test cases remain relevant and up-to-date, minimizing the risk of undetected defects due to obsolete test scenarios. Additionally, the scalability of autonomous test generation allows it to accommodate growing or evolving software projects, effectively addressing the quality assurance needs of increasingly complex systems.

Increased confidence in software releases and positive user experiences  The comprehensive test coverage and efficient defect detection afforded by autonomous test generation foster a higher degree of confidence in the quality of software releases. This increased confidence translates into a reduced likelihood of encountering critical issues in production environments, leading to a better overall user experience. In turn, user satisfaction and trust in the software are enhanced, further solidifying the software’s reputation for quality and reliability.

Challenges and limitations of autonomous test generation

Challenge 1:  Incomplete Requirements and Specifications may result in limited tests  In many real-world situations, the documentation provided for software systems is often incomplete, ambiguous, or inconsistent, which can lead to inadequate test case generation. Autonomous test generation algorithms must be capable of handling these uncertainties, ideally filling in the gaps to create comprehensive test cases. This demands advanced AI techniques that can infer implicit information, which is still an area of ongoing research.

Challenge 2:  Increased Test Counts based on Complexity of features may not be sustainable  As software systems become increasingly complex, the number of potential test cases grows exponentially. This creates a significant scalability challenge for autonomous test generation tools, as generating and executing exhaustive test cases can quickly become infeasible. Researchers are exploring various techniques, such as model-based testing, search-based testing, and AI-guided test generation, to overcome this obstacle. However, striking the right balance between coverage, complexity, and the computational resources required remains an open challenge.

Challenge 3:  Integration with Existing Development Processes  Many organizations follow well-established development methodologies, such as Agile or DevOps, that dictate specific testing practices. Autonomous test generation tools need to seamlessly integrate with these processes to be effective, without disrupting the development team’s workflow. Additionally, compatibility with popular development and testing tools is essential to ensure the widespread adoption of autonomous test generation.

Limitations  Despite the advancements in autonomous software test generation, certain limitations are inherent to the process. One such limitation is the inability to test certain aspects of software, such as usability, user experience, and aesthetics, which require human judgment. While autonomous test generation can produce a large number of test cases, it may not always produce meaningful or high-quality test cases that can effectively reveal defects. This highlights the need for continued research and development in the field to improve the overall quality and effectiveness of autonomously generated test cases.   

The importance of combining autonomous test generation with other testing techniques

While autonomous software test generation offers the potential to reduce manual effort and enhance test coverage, it should not be considered a one-size-fits-all solution to all testing challenges. To achieve comprehensive and effective testing, it is crucial to combine autonomous test generation with other testing techniques, harnessing their complementary strengths to address various aspects of software quality. 

Complementing Test Coverage

Autonomous test generation excels in creating test cases that cover a wide range of scenarios, based on the given requirements or specifications. However, as mentioned earlier, certain aspects of software quality, such as usability and user experience, require human judgment and cannot be effectively tested through autonomous test generation alone. By combining autonomous test generation with manual testing, organizations can ensure that both functional and non-functional requirements are adequately addressed.  Additionally, integration with other automated testing techniques, such as unit testing, integration testing, and system testing, can further bolster test coverage. While autonomous test generation can identify potential defects at a higher level, these other testing techniques can dive deeper into the code to catch issues that may not be apparent during higher-level testing.

Leveraging Domain Knowledge and Expertise

Incorporating domain knowledge and expertise is essential in the testing process, as it enables testers to create test cases that reflect real-world scenarios and potential edge cases. Autonomous test generation can struggle to capture this nuanced understanding of the software’s intended use. By combining autonomous test generation with domain-driven and expert-guided testing, organizations can ensure that test cases are not only comprehensive in terms of code coverage but also relevant and meaningful in terms of actual usage.

Reducing Test Suite Maintenance Effort

Test suite maintenance is an often-overlooked aspect of the testing process, as test cases must be updated and adapted to accommodate changes in the software’s requirements and functionality. While autonomous test generation can efficiently create new test cases, it may struggle to maintain and update existing test suites. By integrating autonomous test generation with techniques such as test case prioritization and regression testing, organizations can effectively manage their test suites, ensuring that they remain relevant and effective over time.

Enhancing Quality (and maturity) of Testing Strategy

Combining autonomous test generation with other testing techniques can lead to improved test case quality. Techniques such as mutation testing, which assesses the test suite’s ability to detect faults by injecting artificial defects into the code, can be employed to evaluate and enhance the quality of autonomously generated test cases. By iteratively refining the test cases, organizations can ensure that their test suites are not only comprehensive but also effective at detecting defects.

Wrapping up

Autonomous test generation, powered by AI and ML technologies, has the potential to revolutionize the software testing landscape, delivering significant benefits in terms of efficiency, effectiveness, and scalability. By automating the generation and execution of test cases, this approach promises to enhance software quality, foster a higher degree of confidence in software releases, and improve user satisfaction.

However, it is important to acknowledge the challenges and limitations associated with autonomous test generation, such as handling incomplete requirements, addressing scalability and complexity, generating adequate test oracles, and integrating with existing development processes. Furthermore, autonomous test generation should not be considered a standalone solution; rather, it should be combined with other testing techniques to ensure comprehensive and effective testing that addresses both functional and non-functional requirements.

As the software industry continues to evolve and grow, the need for efficient, effective, and scalable software testing methods will only increase. By embracing the opportunities and addressing the challenges presented by autonomous test generation, software developers, testers, and industry practitioners can leverage the power of AI-driven testing to deliver high-quality, reliable, and secure software products that meet the ever-changing demands of today’s complex digital world.  

Author

Alex Martins Vice President of Strategy at Katalon, Inc.

Alex is a seasoned leader in the technology industry with extensive international business experience in agile software engineering, continuous testing, and DevOps. Starting out as a developer and then moving into software testing, Alex rose through the ranks to build and lead quality engineering practices across multiple enterprise companies from different industries around the world. Throughout his career, Alex has led the transformation of testing and quality assurance practices, as well as designing enhanced organizational structures to support the culture change necessary for successful adoption of modern software engineering approaches such as Agile and DevOps, and how these are being further transformed with Generative AI.

Katalon was a Gold Sponsor at AutomationSTAR 2024.