Top 5 Common Challenges for Agile Testing Teams

Now that Agile development is mainstream and each day more teams are migrating from Waterfall to Agile development, it’s important to understand how this methodology shift impacts testing teams.  This blog is the first in a series of blogs where I will break down the common challenges that Agile testing teams face and talk about how to solve them.

For those that aren’t familiar with the differences between Agile and Waterfall development, here is a quick refresher:

1. Agile development introduces time-boxed development, where development cycles (called Sprints) are shorter and limited in scope.  Agile sprints are normally 2 weeks to a month in duration whereas Waterfall development cycles are normally many months.
2. Agile development introduces continuous integration, which means that code is checked in daily (normally several times per day) and re-compiled at the same time.  This means that the software is constantly changing.  Waterfall development waits until all software is fully developed before compiling for testing, which could be many months from the day development starts.
3. Since Agile development is done in smaller development cycles (with limited functionality being incrementally developed), requirements are smaller and can be changed as development progresses.  This is done to ensure that the software delivered is what the client needs, not necessarily exactly what was defined up front.  Waterfall is much more structured, where requirements are fully defined and designed up front with very strict rule for change management.

Agile Testing Challenges

Because of these differences, Agile introduces additional challenges for testing teams.  Below are 5 common challenges that Agile testing teams face and a quick description of how you can mitigate them.  In the coming weeks, I will be writing blogs that dive deeper into each challenge with more specific examples of how to solve them.

 

5 Common Challenges for Agile Testing Teams

1. Inadequate Test Coverage – With continuous integration and changing requirements, it can be easy to miss critical tests for any requirement.  This can be mitigated by linking tests to user stories for better insight into test coverage and analyzing specific metrics to identify traceability and missing test coverage.  Another cause of missing test coverage is due to code being changed that was not anticipated.  To mitigate that, source code analysis is needed to identify modules that were changed to ensure that all changed code is properly tested.
2. Code Broken Accidentally due to Frequent Builds – Since code is changed and compiled daily, the likelihood of code breaking existing features is much higher.  To attack this issue you must have a way of running a series of tests against each build.  Since most of us are resource constrained, it is not practical to have testers do this daily so we must rely on automated testing to do this for us. 
3. Early Detection of Defects – Defects are substantially more expensive to fix later in the development cycle.  In other words, if you find a defect during requirements definition, it is much cheaper to fix and has less impact on future coding than those found late in the testing cycle or even worse, in production.  To resolve this issue, your team can do frequent code reviews to spot issues early.  Another option is to run static analysis tools on your source code — these are great at finding missing error routines, coding standard derivations, and data type mismatch errors that can crop up in production.
4. Inadequate API Testing – Most software is now designed with a service orientated architecture that exposes their APIs publicly so that other developers can extend the solution.  For those of us developing APIs, it can be easy to overlook API testing because of the complexity of doing it.  Many testers do not have the skills to test APIs because it normally requires strong coding skills to do so.  To prevent missing API tests, there are tools that allow testers to test the API without strong coding skills, so this is a great way to ensure that these services are fully tested.
5. Performance Bottlenecks – As software becomes more mature, complexity normally increases.  This complexity adds more lines of code which introduces performance issues if the developer is not focused on how their changes are impacting end-user performance.  To solve this issue, you must first know what areas of your code are causing performance issues and how performance is being impacted over time.  Load testing tools can help identify slow areas and can track performance over time to more objectively document performance from release to release.

In summary, Agile is an excellent way to deliver software faster and with higher quality if testing teams understand the unique challenges they are faced with. In the coming weeks, I will be creating a series of blogs that dive into each of these challenges with more specificity and examples. 

Happy testing!