Testers are one of your best resource for truly amazing software products.
With organizations realizing the limitations of the traditional waterfall model of software development and increasingly embracing the agile model, it is worthwhile to examine the role of testers in the agile era. Testers in the agile model work continuously and closely with the development team and the product owner to build and improve quality early rather than be gatekeepers in the end who assure system quality. The role of testers during agile is characterized by earlier involvement during system development, extensive communication with end users early on and an increased focus on quality from the beginning ( as the product is developed and delivered in multiple sprints)
Agile increases communication between the teams; End users are the beginning focus!
As opposed to a sequential way of working from planning, design, execution and reporting, the testers engage with the end user/product owner early on in an agile scenario to ensure that the development team meets the acceptance criteria during delivery of each iteration or sprint. Therefore the tester would contribute to enriching/clarifying the user stories and review of code. This would ensure that the output from each sprint is in line with the expectations of the product owner. Early communication with the product owner ensures that requirements (features) being implemented are validated by the product owners. The focus on extensive communication is driven by the agile methodology with its stress on interactions between team members with reduced emphasis on processes and tools. Hence testers with superior interpersonal and analytical skills would add more value in the agile situation than those with superior technical skills. Shared processes with less emphasis on documentation would work better than rigid processes and tools. Such shared processes should be allowed to evolve during the course of the project progress to ensure that errors do not repeat.
Productivity Gains = Increased ROI
When working in the agile mode, testers need to shed the habit of being driven by bug metrics. It would be better to work with the developers to fix the bug than spend time to write out a detailed defect report, both of which consume the same time. Some of the serious challenges in agile include the lack of complete documentation or a ‘code freeze’ period. A workable option to overcome these challenges would be to increase the frequency of interaction with the end users/product owners and write easily maintainable test cases. Testers should also be able to automate some parts of customer acceptance testing. Automating those scripts that are most frequently executed and are fairly stable would also result in productivity gains through effort reduction and schedule compression.
Testers Need Access to Developers and the Code
Other challenges facing testers in agile include the lack of availability of working code early on during testing. In some instances, this leads to testing being deferred to the subsequent iteration of development. Fallout of this approach would be the lack of integration of the testers with the rest of the team and reduces communication. This would be akin to a traditional waterfall model and can negate the advantage of the agile model.
The Positive Results Outweigh the Challenges
In summary, integrating testers in the agile environment has its own challenges. This can be overcome through early involvement of testers in user story development sessions, effective communication and pairing them with developers early on in the development life cycle. The once thought tried and true linear development and testing method is hopelessly outdated. It is time to reevaluate how we approach testing. This field is very slow to modernize, but new trends and techniques are moving this forward. As this field is expanding and taking shape, new tools have been designed to meet the needs of real testers. According to some of the leading QA testing companies, The blending of techniques that are capable of providing the speed, transparency and flexibility that modern software development demands are necessary for this to happen.