The role of the UI test automation engineer is rapidly becoming obsolete due to the rise of autonomous AI-powered testing platforms like Testaify.
TABLE OF CONTENTS
- Is This the End of the Test Automation Developer Role?
- A Short History of GUI Test Automation
- Test Automation Engineers Are Still Here!
- Final Thoughts
Is This the End of the Test Automation Developer Role?
For some time, we've been discussing the rise of autonomous software testing. The momentum is now undeniable, especially as Forrester shifts its focus from continuous automation testing (CAT) platforms to autonomous testing platforms in their latest report. We'll delve deeper into this shift in a future blog post.
Is the test automation role coming to an end?
In this post, we want to talk about something we have mentioned before, but it is rarely discussed in the testing community. To be honest, listening to the software testing intelligentsia these days is like listening to US Democratic Party politicians trying to explain why they lost the 2024 election. They have no clue how the world has changed around them.
Sorry for the light reference to politics, but I couldn't find a better image to illustrate the current reality denial bubble that many software testing thought leaders inhabit. In this blog post, we want to crack that bubble.
Let’s be clear: autonomous testing platforms will make UI test automation developed by humans obsolete. The act of hiring someone to write test automation scripts in ten years will be as strange as hiring film projectionists today.
There, I've said it! The end of human-generated UI test automation is closer than you might think. For those closely following industry developments, it's evident that AI tools will be a staple in every development team's toolkit. It's also clear that these tools will render specific roles obsolete, reshaping the testing landscape as we know it.
In the world of software testing, the first job becoming obsolete is the UI test automation engineer. Let’s explain why.
A Short History of GUI Test Automation
The emergence of UI test automation coincided with the increasing importance of software as a ubiquitous necessity in all aspects of work. As the need for software continues to grow, the need for testing increases, too. Many organizations started by creating QA (Quality Assurance) teams. Those teams help define the early software testing processes. They started designing and executing test cases. Initially, software testing was primarily a manual process.
As the software packages grew in size, the number of test cases increased. The time it took to execute all the tests increased considerably, and so did the number of people in QA departments. It became clear that if we could not find a way to accelerate testing, we would reach a point where we would spend most of our time executing tests rather than developing software.
Because QA departments were primarily focused on functional testing at the system level, we ended up with vendors creating GUI test automation tools. While vendors attempted to present these tools as something that non-coders could use, that illusion quickly dissipated. A new role was born, the Test Automation Engineer (or Developer).
QA departments experienced significant growth, and in the early days, these tools were expensive. They were all focused on Windows GUI test automation. In other words, test automation increased the investment in QA.
The Internet Wave
Several changes have occurred in the last three decades that have altered the test automation landscape. First, there was the emergence of the Internet and its standards-based interfaces, which utilized HTML. Test automation vendors reacted by treating this as another interface and created tools to support it.
One problem that has plagued this industry since its early days is that GUI test automation is fragile and not easy. While companies dream of automating all their tests and completing regression cycles in a fraction of the time, most companies have never experienced such success.
Historically, most companies have been able to automate only 30% or less of their test inventory. I had the privilege of leading a QA department at Ultimate Software and achieving above 80% test automation coverage. But that was an expensive endeavor driven mainly by willpower rather than anything else.
The Agile Wave
The emergence of agile software development was another significant wave that left its mark on test automation. Agile testing reduced the time spent on system testing while significantly increasing the number of unit and integration tests, a shift that you, as a professional in this field, are likely well aware of.
The emergence of the Agile Test Automation Pyramid has significantly influenced test automation practices. This model suggests that the development team should primarily conduct test automation at the unit and integration (service) levels, with UI test automation kept to a minimum.
As you can see, this model suggests that the development team should conduct most of their test automation at the unit and integration (service) levels, and reduce the UI test automation to the minimum possible.
While the pyramid is well-known in the industry, it is not as widely used as many will expect. Most teams dealing with legacy code bases already have significant investments in UI test automation. In my experience, only teams working on new products were able to implement the testing pyramid. Even those teams ended up implementing mutations of it. I am aware of numerous examples from teams where the only test automation consisted of unit tests in their CI/CD pipelines.
Eventually, teams began developing their own approaches. The cloud teams and the open source tools they used became the new standard for UI test automation.
Everything is Cloud, Open Source is the Way!
By the end of the first decade of this century (the end of the 2000s, in case I lost you), most development was focused on cloud tools using web interfaces or native mobile apps that call cloud API services. Additionally, the use of open-source tools has become widespread. Test automation was not an exception, as everyone started using Selenium for web test automation work.
Test Automation Engineers Still Here!
While these changes did not eliminate the role of the automation engineer, they began to have an impact. Agile software engineers started to take on some of the responsibilities by creating unit and integration tests. In a way, this progression paved the way for what we described in our blog post, Testing without Testers. That movement at the largest software companies ultimately led to the removal of many people whose jobs focused on test automation.
Enter The First Testing AI Wave
The first generation of AI testing tools came up in the mid-2010s. These tools' early focus was on helping to improve the execution of test automation test suites. Specifically, they became famous for introducing the concept of self-healing.
As we mentioned earlier, UI test automation is famously fragile. As such, a significant portion of a Test Automation Engineer's work involves babysitting their test automation scripts and making minor adjustments on the fly to keep them running, allowing them to complete regression testing. These early AI tools focus on handling the babysitting process I just described.
While these tools had a limited impact in an industry now accustomed to free tools like Selenium, they paved the way for what was to come.
Autonomous Testing is Coming!
The era of autonomous testing is on the horizon, driven by the advancements in AI. This shift will reshape the testing landscape, rendering traditional UI test automation roles obsolete.
Some vendors in the first wave of AI testing tools have added additional capabilities to their applications, such as test generation. But they cannot implement the whole testing process like Testaify can.
Testaify is an agentic AI autonomous testing platform that discovers your application, designs test cases, executes them, and reports back to the user its findings. We like to describe the process using this diagram:
Behind the scenes, Testaify uses Selenium Grid to execute our test cases. In other words, we create hundreds of test automation scripts and run them in minutes. Not only that, we record every step taken by our tests, which allows the user to replay and easily review the findings.
If you can discover your application, design, and run a thousand test cases every hour, why would you need a test automation engineer?
Final Thoughts
The autonomous testing revolution has been gathering speed. This year, thanks to the AI revolution, we will see the inevitable embrace of these platforms in the marketplace. Ultimately, we will have a tool that can address testing challenges without requiring additional personnel. We will be able to rethink testing and completely restructure what a software development organization looks like.
Testaify is coming soon! Join the autonomous testing revolution now!
About the Author
Testaify founder and COO Rafael E. Santos is a Stevie Award winner whose decades-long career includes strategic technology and product leadership roles. Rafael's goal for Testaify is to deliver comprehensive testing through Testaify's AI-first platform, which will change testing forever. Before Testaify, Rafael held executive positions at organizations like Ultimate Software and Trimble eBuilder.
Take the Next Step
Join the waitlist to be among the first to know when you can bring Testaify into your testing process.
