Quality software initiatives help accelerate time to market, drive new business and reduce customer churn. While more organizations recognize software quality as a strategic priority, some struggle with how to put in a foundation that makes it possible to deliver on the mission.
The most effective quality strategies are backed by the right team and technology strategies. This article presents common organizational structures and a proven software testing technology stack well suited to the strategic pursuit of quality software.
Software Testing Team Structure
The first order of business is getting the right people in place. The testers of the future will sit further left in the application development process, in line with the growing embrace of agile development methodologies. Even those who are not full-time testers but instead split their time between development and testing need relevant testing skills.
Because many types of tests are needed to address the end-to-end application development lifecycle, testers need knowledge about various testing technologies and approaches, including automated and exploratory testing.
Each tester might apply certain domain expertise or test only a portion of the application. However, the team needs a leader who understands testing across the entire application lifecycle and can determine the application’s overall health from a holistic perspective.
Beyond having the requisite skills and experience, those on the modern test team take pride in ownership and the software delivered to market. To that end, they must be willing and eager to learn and adopt the latest QA tools, test frameworks and exploratory testing techniques. In turn, the organization needs to provide options for them to move into management roles as they grow professionally.
Aligning with the Modern DevOps Technology
Organizations must then equip their teams with the right technology stack based on a well-considered technology strategy. Just as the software engineering domain is dealing with a constant influx of new open source and proprietary tools and technology, so is the software testing space. Before exploring individual tools, it’s helpful to understand the application lifecycle development tech stack at a high level.
As the illustration below shows, the technology is bucketed into seven main categories to align with the major phases of the development lifecycle: Plan, Track, Code, Build, Test, Deploy and Monitor.
In a modern technology stack, tools across each development stage are becoming more integrated. This mirrors the emergence of DevOps as a discipline, which is centered on automating and monitoring every phase of software development. As more bottlenecks are removed through integration and automation, one of the largest remaining resides within QA. In line with this, modern organizations are increasingly looking toward QA tools that can be integrated with other tools, and that enable more automated, traceable tests, triggered any time someone touches the application code.
At a high level, the best-of-breed tech stack must enable the test team to track the overall health of the application through test case management. More specifically, the team needs the ability to:
- Track all automated and manual tests
- Track tests executed outside the organization
- Ensure no tests are overlooked
At a more granular level, the team needs tools that enable them to run the following tests at a minimum:
- Unit. This is the smallest and simplest type of test, focused on a separable unit of the application. Each language and framework are typically supported by a defacto unit test framework.
- Functional UI. This testing assesses the external functionality of the application. Behavior-Driven Development (BDD) is an increasingly popular methodology of functional UI testing. The methodology gives product managers and owners a view into application details, lets requirements be used as tests and also helps ensure test coverage in new feature areas. Selenium and Appium are two of the most popular frameworks.
- Functional API. This testing assesses the external functionality of the application. Here it’s important to have support for data-driven testing, along with human-readable tests in the test framework. Postman and SoapUI are commonly used for functional API testing.
- Load and performance. These tests are used to determine the application’s behavior and performance under different load conditions. While many application load and performance testing tools are being released, JMeter is still extremely popular. Other options include tools like NeoLoad, LoadUI, and the testing tools published by industry stalwarts such as IBM and HP.
- Security. This test assesses the security of the application’s code, and at a high level, comes in two forms: dynamic and static. Dynamic tests security while the application is running or being used, while static tests the security in a non-running state. Organizations can take advantage of numerous tools for static code analysis, including Checkmarx. Some languages and Integrated Development Environments (IDEs) include helpful plug-ins. It’s worth noting that many companies hire outside consultants to perform these tests, but everyone on the team must be security-aware to avoid breaches.
While automated testing is the new status quo, non-developers need the ability to read what is being tested. The best approach is managing and tracking all tests in one place, organized by application feature. A good way to evaluate the testing setup is by seeing whether someone new to the environment can easily view tests and arrive at a solid understanding of the application’s function.
Conclusion: Organizing to Ensure the Highest Levels of Software Quality
The team and tool approach will vary by organization. Generally speaking, a robust toolset and well-developed tech enables a flatter org chart. That said, larger companies often include multiple development teams, which translates into several testing and quality org charts to represent the variety of teams and toolsets. Some organizations are structured around individual Scrum teams and given the autonomy to develop their own tech stack and choose their tooling. Giving teams this sort of autonomy can help individuals feel more ownership and get more excited about the work they are doing.
Regardless of the organization’s approach to development and testing, the org chart of the future still includes testers conducting exploratory testing to ensure applications are functioning as intended. By bringing testers earlier into the development cycle – in other words, by shifting them left – organizations can more effectively address all requirements and edge cases.
Standardizing on tools is usually the best approach to ensure no team or team member misses out on any key testing features and that all stakeholders have full transparency into QA. In fact, larger organizations may not be able to flatten their organizations. However, by embracing and aligning with a modern application testing tech stack, even they can support their testing teams most effectively.