Over the past 15 years, software development has been transformed. New approaches allow ever faster development cycles. Modern tools mean you can provide ever-more advanced features to meet the needs of your users. However, over that same time period, automated testing has stagnated, leaving teams struggling to keep up with test debt. CTOs play a critical role in digitally transforming their companies for the better. Here’s why every CTO should leap at the opportunity to create lasting impact by eliminating test debt with AI.
Back then, no one had heard of cloud and “agile’ was a word used to describe gymnasts. Here, we explain how this reliance on outdated QA technology hinders your digital transformation and why you should instead turn to AI-powered test automation.
Selenium works but is showing its age
Selenium was created almost two decades ago. Since then, it has become the dominant approach for test automation. However, Selenium still suffers from three drawbacks.
Slow test creation
Selenium tests are powered by test scripts. These tell the software exactly how to interact with the UI and what the expected outcome is at each step in the test. The problem is, these scripts take hours to create, even for a good test engineer. Once created, they have to be further adapted for each browser or platform the test runs on. That’s a complex matrix to be sure.
Unreliable and brittle test scripts
The single greatest problem for Selenium is how unreliable the test scripts are. Each time your devs release some new code, it is likely to break most of the existing tests. The upshot is, your QA team spends much of their lives fixing old tests. This is euphemistically called “test maintenance”. However, this leads to a far more damaging problem, namely test debt. Put simply, the more tests your team creates, the more of their time is lost to fixing existing tests. Eventually, they face a stark choice between keeping existing tests healthy or adding tests for new features. They have less and less time to spend learning their way around your applications and delivering quality.
Lack of scalability
A third problem with Selenium relates to its age. Fundamentally, it was designed at a time when applications were monolithic and single-threaded. That means, each instance of Selenium can only run a single test at a time. To overcome this, Selenium Grid allows one server to act as a controller, assigning tests in turn to a set of test servers. While it is better than the single threaded approach, it is a million miles from the sort of flexible cloud-based apps we have grown used to in the past decade.
The QA technology gap
When Selenium was released, it revolutionized application development. It was cleverly named as Selenium is the natural antidote for “Mercury” poisoning. Back then, Mercury was the leading test framework and the bane of many teams’ lives. Suddenly, teams could automate much of their testing. However, although widely installed and well understood by QA teams, Selenium has only seen incremental changes and improvements since then.
Record and playback allowed basic tests to be created by recording interactions with the UI. These could then be played back as a test script. However, the scripts were often unstable and needed to be rewritten for each browser being tested.
Selenium Grid allowed teams to marginally scale their Selenium infrastructure by using one server to control multiple tests across multiple servers. Nowadays, plenty of companies will offer you access to cloud-based Selenium testing. However, fundamentally they are just selling you access to their Selenium Grid. This saves you infrastructure costs, but it doesn’t give you real scalability. Certainly not enough to tackle your test debt.
Shallow AI is used to solve specific issues. For instance, these systems try to simplify test maintenance by suggesting fixes from a list of potential alternatives. Or they can create test scripts directly from Gherkin, using simple structured natural language processing. While they do help, they are far from powerful enough to fix the test debt burden.
Selenium wrappers are AI-powered wrappers that surround the underlying Selenium software. These simplify test creation and reduce some of the test maintenance burden. However, under the hood they are still relying on software that’s almost 20 years old. Although wrappers have some ability to help with test maintenance, they actually can have a very negative impact. The faster your team is at creating tests and increasing coverage, the faster your test debt grows. So, wrappers may be exacerbating the problems you face!
To give some idea how far Selenium is lagging behind, you have just to look at other SDLC advances over the same period. It is simply not a fair fight for QA.
Twenty years ago, all software was designed and created using the waterfall model. The process started with defining the requirements. Then designing the functionality. This design was passed to developers, who worked towards a specific delivery goal. Once the release was ready, it passed to QA to check quality, reliability, and functionality. Finally, there would be a red-letter day when the software was ready for release.
Nowadays, most teams follow some version of Agile development. The Agile Manifesto was actually written in 2001, a couple of years before Selenium. However, it initially wasn’t widely adopted. But that all changed once managers realized how effective it was. Modern teams often combine agile development with related approaches, such as CI/CD. The upshot is, your business can react far faster to the needs of your users.
Modern teams can rely on a whole range of tools to help deliver better software, faster. These include libraries and 3rd party services that implement key functionality, and low-code or no-code tools that allow non-technical people to create software. You are no longer limited by the skills of your developers. The resulting applications can offer better performance, increased functionality, and improved user experiences. Effectively, this approach has gone a long way towards eliminating the sorts of technical debt that used to beset development teams.
One of the most obvious changes in recent years has been in how applications are delivered to end-users. Two decades ago, this required you to run your own servers that had to be manually configured by a team of sys-admins. Since then, we have seen four significant leaps in technology.
Paravirtualization. Here, each physical server can support dozens of virtual servers. These can be enabled in minutes, migrated from server to server, and backed up like any file. The result is a far more efficient use of expensive resources.
Cloud. One of the earliest clouds was Amazon’s Elastic Cloud Compute (ECC). This service allowed anyone to buy access to virtual servers on-demand. The result was the vast boom in SaaS, mobile, and web apps that drove the smartphone revolution.
Platform as a Service. PaaS abstracts away the server, allowing you to think of applications as assemblies of services running together on a platform. This solved many of the problems with scalability and deployability that still affect IaaS cloud services.
Containerisation and serverless. The latest advance gets rid of the concept of servers or platforms completely. Now, your application simply consists of services or micro-services orchestrated into a coherent whole. The provider takes care of all underlying computing and storage. This offers unlimited scalability, greater flexibility, and improved reliability.
How AI-powered test automation closes the gap
Functionize’s CTO and Founder, Tamas Cser, saw how test debt was holding back digital transformation. His solution was to apply machine learning and Deep AI to solve Selenium’s endemic problems. Functionize allows teams to eliminate test debt, test smarter, and deliver more reliable software.
- Test maintenance is slashed thanks to our unique approach to self-healing. This means that as your UI and application evolve and change, your tests evolve too. This is only possible thanks to the millions of data points we collect with every single test run.
- Test creation is much simpler using our smart test recorder, Architect. This allows smart tests to be recorded in minutes. As the test is created, the system is creating a rich ML model of your application. Architect also includes advanced features to enable true end-to-end testing, testing of 2FA, and the ability to verify file downloads or visual elements.
- Analyzing test results is much easier thanks to our visual-testing approach. This makes it really easy for your team to analyze bugs and to share these with the developers. This is backed up by our suite of integrations, which include Jira, TestRail, and Slack.
The net effect of all this is that your team will see test debt rapidly vanish. That means they can dedicate more time to learning applications, creating more tests, faster, and delivering more reliable software.
The impact on your job as a CTO
Most CTOs we speak to are focused on implementing or completing digital transformation projects that will reshape their companies for the better, within budget, and on time. That’s where Functionize can add significant value
1. Deliver digital transformation. The gap between the evolution of development tools and their related process improvements, and testing tools and processes, has become a significant bottleneck in digital transformation. With Functionize you remove one of the biggest roadblocks to digital transformation. In one step you will take your testing from a technology created 20 years ago to one specifically designed for modern applications.
2. Achieve more with the same resources. Functionize will also allow you to achieve better results without needing to increase resources. Indeed, because it is so powerful, our test solution will help your team deliver much more reliable software in a shorter period of time. This leads to a demonstrable and meaningful ROI. It also allows you to catch up to competitors who have already closed this gap.
3. Accelerated development of new features. Often, QA teams are the roadblock for releases simply because they are drowning in test debt. Remove that test debt and you unlock the true potential of your team. That means you can deliver all the new features you and your users want. For most QA teams, 60 of every hundred hours is spent on test debt. Imagine eliminating a significant portion of that and the effect it can have on your digital transformation process.
4. Seamless Adoption: Functionize is designed to seamlessly integrate with your existing dev/sec/ops infrastructure for maximum efficiency and effectiveness.
If you want to find out more, reach out to our team for a demo.