QA Is A Philosophy Of How We Work Not A Role

Quality Assurance Shouldn't Be a Role—It Should Be the Philosophy Behind How We Build Software

As an engineer, I’ve seen the evolution of software development practices and the role of quality assurance (QA) within that process. Traditionally, QA was seen as a distinct role, often siloed away from development teams. QA professionals would manually test software, trying to catch bugs before release, and developers would frequently move on to the next feature, leaving the testing phase as an afterthought. While this approach had its place in the early days of software development, it’s increasingly clear that it’s no longer viable in today’s fast-paced, high-stakes environment.

The Philosophy of Quality: Built-In, Not Bolted-On

Quality assurance should not be a distinct role within a software development team. Instead, quality must be a fundamental part of the software development philosophy—a mindset that guides every decision we make, from the first line of code to the final deployment.

When quality is seen as something that is “added” at the end of the process, it becomes just another box to check off. But when it’s baked into every stage of development, it transforms how we think about the software we build. Each line of code is written with the awareness that it must meet the highest reliability, performance, and usability standards. This shift in mindset is essential to achieve the ultimate goal: delivering high-quality software to users as quickly and efficiently as possible.

Shift Left - Product: Building Quality In

A vital component of the shift-left approach is ensuring that quality is considered during the development and product planning and design stages. Building quality into the product means incorporating QA principles into the earliest discussions about features and user stories. This involves cross-functional collaboration between developers, product managers, designers, and QA engineers to identify potential risks, define clear acceptance criteria, and ensure alignment on the feature’s goals. By thinking about quality from a product perspective, teams can anticipate user needs, mitigate technical risks, and prioritise features that deliver value without compromising reliability. This proactive approach allows quality to influence product decisions, shaping how features are conceptualised and built, ultimately reducing the rework and redesigns that might occur if issues are only discovered later in the development cycle.

Shift-Left - Engineering: Catching Issues Early

As discussed, a key strategy to integrate quality into the overall development process is adopting a "shift-left" approach to testing. By involving testing from the very beginning of the development cycle, we can catch issues early when they are easier and cheaper to fix. This approach contrasts sharply with the traditional method, where testing is conducted primarily at the end of the development cycle.

By shifting testing left, we ensure that quality is considered at every stage. For instance, implementing static code analysis tools during the coding phase can help identify potential issues in the code before it’s even run. This proactive approach reduces the risk of bugs making it into production and helps maintain a high standard of code quality throughout the development process.

Behaviour-Driven Development (BDD) and Test-Driven Development (TDD)

Another way to embed QA into the development process is through practices like Behaviour-Driven Development (BDD) and Test-Driven Development (TDD).

• BDD encourages collaboration between developers, QA engineers, and product owners to write test scenarios in a shared language that everyone can understand. This ensures that the entire team clearly understands the system's expected behaviour, which helps prevent misunderstandings and misaligned expectations. The test scenarios created in BDD also serve as living documentation, always up-to-date with the current state of the code.
• TDD takes this further by requiring developers to write tests before writing the production code. This practice forces developers to think about the requirements and design of the code from a testing perspective, leading to better-designed, more reliable software. By writing tests first, developers ensure that their code meets the required functionality from the outset, reducing the likelihood of bugs later in the process.

Automated Testing: The Backbone of Modern Software Quality

Automated testing is the cornerstone of this quality-first philosophy. In an era where software updates are deployed multiple times daily, manual testing simply cannot keep up. Automated tests provide a consistent, repeatable, and efficient way to ensure that each new code change doesn’t introduce new bugs or regressions.

Here’s why automated testing should be a massive part of your software development process:

• Speed: Automated tests can run in parallel and at scale, allowing for fast feedback loops. This speed enables continuous integration and continuous deployment (CI/CD) pipelines, where code changes are automatically tested and deployed, often within minutes.
• Consistency: Unlike manual testing, automated tests are not prone to human error. They run the same way every time, ensuring consistent results. This consistency is crucial for maintaining a high level of quality over time.
• Coverage: Automated testing can cover many scenarios, including edge cases that might be overlooked in manual testing. Unit tests, integration tests, and end-to-end tests together provide a comprehensive safety net that catches bugs early in the development process.
• Scalability: As your codebase grows, so can your automated tests. Manual testing, on the other hand, becomes increasingly unmanageable as the complexity of your software increases.

Quality Gates in CI/CD Pipelines

Quality gates are crucial in the CI/CD process, ensuring that only high-quality code makes it to production. These automated checks can be integrated into your CI/CD pipeline, where they enforce standards that must be met before code is merged or deployed.

Quality gates can include:

• Code Coverage Requirements: Ensuring that a minimum percentage of the codebase is covered by automated tests (use with caution as this can lead to gaming the system by adding tests of little value but high coverage)
• Static Code Analysis: Checking for code smells, security vulnerabilities, and other potential issues.
• Passing All Tests: Ensuring all unit, integration, and end-to-end tests pass successfully.

Implementing these quality gates can prevent low-quality code from reaching production, thereby reducing the risk of bugs and other issues affecting your users.

The Role of Manual Testing: Focused, Specialised, and Minimal

This is not to say that manual testing has no place in modern software development—it does. However, its role should be much more focused and specialised. Manual testing should be reserved for exploratory testing, usability testing, and other scenarios requiring human intuition and creativity.

Manual testing should be the smallest part of the standard build and release process due to its inherent drawbacks:

• Time-Consuming: Manual testing is slow. In a world where speed to market is crucial, relying heavily on manual testing can create significant bottlenecks.
• Error-Prone: Humans make mistakes, especially when performing repetitive tasks. This leads to inconsistent results and a higher chance of bugs slipping through the cracks.
• Lack of Consistency: Different testers might interpret test cases differently, leading to variations in test results. This inconsistency can undermine the reliability of your QA process.

Advanced Deployment Techniques: Feature Toggles, A/B Testing, and Dark Launching

In addition to the shift-left testing, BDD, TDD, and quality gates, advanced deployment techniques like feature toggles, A/B testing, and dark launching further enhance the quality of software delivered to users.

• Feature Toggles: Developers can deploy new features to production in a disabled state using feature toggles. This allows for gradual testing and enabling of features for specific user groups without affecting the entire user base. It’s a powerful way to test new features in production environments without the risk of impacting all users.
• A/B Testing: A/B testing involves deploying different feature versions to separate user groups to determine which performs better. This method helps fine-tune features based on user data and preferences, ensuring that only the best version is rolled out to all users.
• Dark Launching: Dark launching involves deploying features to production without making them visible or accessible to users. This allows the development team to monitor the feature's performance and stability in a live environment, identifying potential issues before making it available to the general user base.

These techniques allow teams to mitigate risk while continuously delivering new value to users. They provide a controlled environment for testing and validating new features, ensuring that only the best and most stable features reach the wider audience.

The Virtuous Circle of Investing in Quality Assurance Engineering

Investing in test automation and quality assurance engineering creates a virtuous circle that benefits the entire software development lifecycle. As you invest more in automated testing and robust QA practices, the immediate benefits include faster release cycles, fewer bugs in production, and higher user satisfaction. However, the long-term benefits are even more significant:

• Continuous Improvement: Automated tests and quality gates provide constant feedback, allowing teams to learn from mistakes and continuously improve their development practices. This creates a culture of continuous improvement, where quality is constantly enhanced.
• Reduced Technical Debt: By catching issues early and ensuring that code meets high-quality standards before merging, you reduce technical debt accumulation, making your codebase more maintainable and scalable over time.
• Increased Confidence: With a robust automated testing suite in place, teams can deploy new features and updates with greater confidence, knowing that the chances of introducing bugs are minimised. This confidence enables faster innovation and a more agile response to changing market needs.
• Empowered Teams: As developers take ownership of quality through practices like TDD and BDD, they become more engaged and motivated. This leads to a more empowered team invested in delivering high-quality software.

This virtuous circle drives better outcomes for users and customers and fosters a healthier, more productive engineering culture.

Conclusion: Quality as a Shared Responsibility

Quality assurance is no longer a task to be handed off to a separate team at the end of the development cycle. It’s a shared responsibility that starts with the first line of code and continues through to deployment. Automated testing plays a critical role in this process, enabling fast, reliable, and scalable quality assurance that aligns with the demands of modern software development.

By embracing a philosophy where quality is built-in, not bolted-on, and by adopting advanced practices like shift-left testing, BDD, TDD, quality gates, and sophisticated deployment techniques, we can deliver better software, faster. And in today’s competitive landscape, that’s not just a nice-to-have—it’s essential.

In summary, QA shouldn’t be a role; it should be the philosophy that underpins everything we do as engineers.