Quality Assurance often finds itself relegated to a series of tactical checkboxes-run these tests, verify those features, report these bugs.
In the short term, so what? But if you care enough to incorporate QA, you want to build long-term. This narrow view leads to a brittle and unsustainable QA process. As systems grow more complex and development cycles shorten, this tactical approach crumbles under its own weight, unable to scale or adapt to new challenges.
Building maintainable and scalable QA requires a strategic mindset. It's about creating an environment where quality is woven into the fabric of your organization, where it's not just a phase but a continuous, evolving process. It's about fostering a culture where everyone-not just QA engineers-is responsible for quality.
We've talked before about how we need to kill QA. But what we're talking about is killing QA as a tactical process. It must die as a bolted-on, last-box-checked component of the software development lifecycle.
Quality needs to subsume the entire organization.
Now, this is obviously a stupid thing to say. It's not like developers are striving for non-quality. But the reality is that quality often gets sacrificed on the altar of deadlines, feature pressure, and the relentless pace of modern software development. It's not that developers don't care about quality; it's that the system often doesn't prioritize it effectively.
So when we say quality needs to subsume the entire organization, what we're really advocating for is a fundamental shift in how we perceive and prioritize quality:
By reframing quality in these ways, we move beyond the simplistic view of QA as a series of tests or a phase in development. Instead, we create an environment where quality permeates every decision, every line of code, every product discussion.
The challenge, of course, is in the implementation.
How does siloed quality manifest?
QA engineers often need developers to add specific CSS selectors into the app for end-to-end testing. In theory, this should be a straightforward request. However, in practice, it often plays out like this:
This seemingly small interaction exemplifies the larger problem of siloed quality practices. The first is misaligned priorities. Developers and QA engineers are working towards different immediate goals, even though their ultimate objective-a high-quality product-is the same. They are in this position because of inefficient communication. The initial request from QA to developers isn't effectively conveyed or doesn't convey the importance of the task.
As we said about seeding quality in the organization, this really stems from alack of shared responsibility. Here, the developers don't see adding these selectors as part of their role in ensuring quality. Thus, we get the bane of dev teams everywhere: increased technical debt. When QA engineers add selectors themselves, it can lead to inconsistencies in the codebase and potential maintenance issues down the line.
More pragmatically, we need to set out specific strategic best practices that allow us to execute at a higher level than the tactical best practices we hear about in testing.
The definition of "done" should be expanded to include quality-related tasks. This could include:
This can also include introducing quality gates at various CI/CD pipeline stages. These gates should check for functional and non-functional requirements before allowing code to progress. This will also mean including QA engineers in planning sessions to ensure quality considerations are baked into task estimations and acceptance criteria and implementing quality-related OKRs for all team members, not just QA engineers.
AI is the future of QA. QA engineers will then become responsible for the strategic drive for quality.
AI testing tools can:
Automating QA allows you to "shift testing up," where QA engineers can focus on higher-level quality strategies and exploratory testing. This shift enables teams to improve overall product quality while increasing the testing process's speed and efficiency.
Quality metrics-escaped bugs, defects, time to test-are how QA engineers rate themselves. But in siloed organizations, these metrics are kept to the QA teams.
The practice should be to hold everyone accountable to these metrics. This means making quality metrics visible and important across all teams, from development to product management to executive leadership. Quality becomes a shared responsibility by integrating these metrics into company-wide dashboards and regular review processes.
This visibility can drive behavior change, encouraging developers to think more critically about quality during development and helping product managers prioritize quality-related work. Moreover, it can facilitate more informed decision-making at all levels of the organization, balancing feature development with quality improvements.
Things will go wrong. A bug will escape into the wild. Tests will fail.
But when fingers get pointed, everyone retreats and stops sharing. Regular blameless post-mortems allow teams to openly discuss what happened, why it happened, and how to prevent similar issues in the future. This approach fosters a culture of learning and continuous improvement.
By focusing on the process rather than individuals, teams can identify systemic weaknesses and implement more robust solutions. Blameless post-mortems also encourage transparency and trust within the team, as members feel safe sharing their perspectives without fear of repercussion. This open dialogue often leads to innovative ideas for improving quality processes and can ultimately result in more robust, more resilient systems.
How do we make this shift without disrupting productivity? How do we measure success in this new paradigm? How do we balance the need for speed with the demand for quality?
Forward-thinking organizations must grapple with these questions as they build and scale truly maintainable QA processes.
The truth is, there's no one-size-fits-all solution to building and scaling maintainable QA. Each organization, each product, each team has its unique needs and constraints. However, this doesn't mean we're left without direction. Instead of focusing solely on specific practices or tools, we need to elevate our perspective and consider QA an integral part of the development ecosystem.
By shifting our focus from short-term tactics to long-term strategy, we can create a QA process that keeps pace with rapid development and drives innovation and quality. We're building AI testing to allow engineers and teams to do exactly that. If you want to see how AI testing can increase product quality while allowing you to move to a more strategic QA mindset, come talk to us.