Traditionally, developers wrote code, and QA engineers then tested it manually.
Yet sticking to tradition is not often a recipe for innovation. Just because the role of developers has conventionally been limited to writing software itself—not testing it—does not mean that this is how things have to be.
On the contrary, there is a lot to be said in favor of transforming your QA process by allowing developers to play a more central role in writing software tests—thereby enabling an easy path to test automation. Let’s take a look at the reasons why.
Traditional IT Specializations
The typical engineering organization consists of three main job roles:
- Developers or software architects, who design applications and write the code to implement them.
- QA engineers, who test the application code written by developers in order to ensure that it behaves as expected within a variety of different environments. Traditionally, QA tests have been performed manually.
- Sysadmins or IT Ops engineers, who build software, deploy it into production environments and manage it once it is live.
Software delivery life cycles at most organizations were designed to reflect the division of labor described above. Each of the three main groups “owns” a particular part of the software delivery process, and there is little overlap between domains. When developers finish writing code, they hand the code off to QA engineers, who in turn hand it off to IT Ops when it is ready to deploy.
Thinking Beyond Tradition: DevOps
Although it is possible for the different groups of IT engineers to collaborate and work in parallel, enabling maximum efficiency and software quality requires thinking beyond the conventional tripartite division of IT labor.
The DevOps movement reflects one effort to achieve this type of innovation. DevOps encourages closer collaboration between developers and IT Ops engineers. By adopting such an approach, organizations ensure that developers are more aware of the challenges facing their applications in production, while IT Ops is able to communicate more clearly with developers so that application updates can solve production problems faster.
By now, DevOps techniques have achieved widespread adoption. DevOps is now a commonly accepted approach to organizing labor for IT teams large and small.
Going Further: Rethinking Developer and QA Roles
Yet DevOps is not the only way to improve traditional software development practices. IT teams can achieve even more innovation by restructuring the relationship between development and QA roles.
Specifically, organizations can significantly increase the part that developers play in writing automated software quality tests. Doing so makes sense for several reasons:
- Developers know the code of the applications they write better than anyone. They are therefore ideally positioned to determine which tests to write.
- Developers are already skilled at writing code. Although writing automated software tests may require them to learn some new software frameworks, their skillsets should be readily extendable into this realm.
- By involving developers in the software testing process, IT teams ensure that developers have better visibility into their code as it moves down the development pipeline. In turn, they are better positioned to use that insight to improve the application code. If developers learn that a particular interface feature is causing problems during testing, for example, they will know that they should update the code for that feature.
- While asking developers to write tests may lead organizations to believe they can eliminate separate team of QA engineers, this is not really the case. Developers have a deep understanding of the code base and technology stack, while QA has well-honed feel for use cases and usability. Integrating development operations with QA can bring the best of both worlds together and lead to even higher quality products from a user perspective..
- Involving developers in testing helps to break down the silos that typically separate different engineers from one another. Destroying silos is one of the driving mantras of the DevOps movement. Breaking down silos between developers and QA engineers is just as wise as doing the same for developers and IT Ops.
Expanding the role played by developers in writing software tests is thus not only eminently feasible, but also introduces significant efficiencies in the way software is written and deployed. It allows organizations to achieve even more innovation than they already are by pursuing conventional DevOps practices.
Developers & QA - Better Together
Allowing developers to write software tests does not mean eliminating traditional QA roles. QA engineers remain valuable to any IT organization; they are the experts in improving test efficiency, increasing test automation, and ensuring that testing routines can scale along with the rest of the software delivery lifecycle.
However, as IT practices increasingly emphasize collaboration and efficiency, QA roles will change. It will not be enough to rely on separate teams to write code and test code. Nor will testing strategies that are based primarily on manual tests suffice. This approach may have worked in the past, and it might continue to work as long as your organization is willing to accept inefficiency, but it will not power innovation or create new business value.
Staying ahead of competitors requires a lean and mean software delivery process. Rethinking the role of developers in QA workflows is an important step in achieving software delivery efficiency.