Dec 7, 2023, Consulting

How to manage testing and work with QA teams

Aneta Skoczewska Business Consultant
managing QA teams
There's been a ton of digging around to understand why software projects stumble and fall. One of the most common hurdles is not prioritizing quality assurance during the development process. And even tiny errors that slip through the net can lead to big financial hits.

The importance of QA

The path to crafting top-tier software? Put in place effective QA management, equipped with the right tools and methods for creating a bug-free product. The term ‘software quality management’ actually encompasses three key areas:

  1. Quality assurance

  2. Quality control

  3. Testing

And trust us, they’re all just as important as the next. 

Software Quality Assurance (SQA) is a key facet of quality management that encapsulates a strategically planned assortment of organizational actions. Its goal is to enhance the software development process and instill quality standards that keep glitches and bugs at bay.

Software Quality Control (SQC), another vital piece of the quality management puzzle focuses on meeting quality requirements. It revolves around product-oriented activities that vet software products for their quality, pre-release. 

Testing is the fundamental action directed at spotting and ironing out technical hitches in the software’s source code, while also evaluating the product’s overall usability, performance, security, and compatibility.

  • A great cautionary tale about the importance of QA is the story of Flud, once hailed as the “first true social newsreader.” This app, designed for iPad, iPhone, Android, and Windows Phone, came undone because of inadequate QA. The Flud squad was all about developing and coding, almost to the point of neglecting everything else. By the time the product hit the market, it was crawling with bugs and packed with discrepancies. Sure, they eventually fixed everything, but by then the damage was done. The app’s poor reputation and terrible user experience meant it was doomed to failure. And so Flud was discontinued. (Wikipedia)

Create a testing and QA roadmap

Testing and QA procedures ought to be systematically charted, defined, and logged. Great documentation is the magic wand that cultivates effective communication within your software squadron. So, let’s deep dive into a few key documents that fuel the QA journey.

  • Test Policy: Think of this as your QA manifesto, outlining your company’s testing principles, objectives, and how testing is performed. This comprehensive guide encompasses the essence of testing for your organization, software testing standards for projects, testing terminology, tools aiding testing, methods to measure testing efficiency, and ways to upgrade testing processes.

  • Quality Management Plan: This blueprint indicates an acceptable quality level for your product and outlines how to achieve it. Its aim is to keep your project management on track by defining roles, responsibilities, and quality standards. It outlines the software’s quality requirements and details how they will be assessed.

  • Test Strategy: As a tactical document derived from business requirements, a test strategy defines software testing methods to accomplish testing objectives. For larger projects, it’s developed as a separate document from which each test plan can be advanced.

  • Test Plan: It provides an overview of what, when, and how to test, outlining the testing scope, activities, objectives, and helping mitigate risks. A well-crafted test plan includes a schedule for all necessary testing activities and clearly defined team roles.

  • Test Cases: They’re sets of input values, execution preconditions, expected results, and execution postconditions, developed for a specific testing goal.

Adopt a test-centric software development approach

Revamping your development approach to be more test-oriented can significantly boost the quality of your software. One way to do this is extreme programming (XP), a methodology centered on enhancing software quality and flexibility to adapt to changing requirements. 

Let’s then focus on two XP practices related to testing:

1. Test-driven development

TDD flips the script by having tests written before any code implementation. It’s a test-first methodology that emphasizes a short development cycle, starting every new feature with a written test. Initially, such a test fails because the code isn’t developed yet, but the next step involves writing code that corresponds to the test, passing it successfully. Lastly, the code is refactored until all tests are passed, and the benefits are a higher quality product, cost-effective debugging, simplified code, and increased productivity.

2. Pair programming

Two heads are better than one, right? That’s the essence of Pair Programming, an extreme programming technique that involves two developers working on the same code. One writes the code (Driver) while the other (Navigator) gives suggestions and guidance. Roles can be swapped at any point. As a result you have superior code quality, lesser bugs, better knowledge sharing, and more streamlined code. This pair-based approach can also be applied to testing, fostering a brainstorming environment that increases productivity and results in a higher quality product.

Test early & often with a shift-left approach

The shift-left testing approach is a game-changer, as it urges you to kick-start testing activities at the onset of the development process, instead of relegating it to the last stage, as traditional methodologies often do. It involves:

  • Planning Ahead: Never leave testing to the last minute. It can result in bottlenecks and hamper progress. Incorporating a testing schedule from the start can nip bugs in the bud and ensure smooth functionality.

  • Reviewing Requirements: Engage testers in conversations with customers and stakeholders, facilitating a deep-dive into requirement analysis.

  • Frequent Testing: Run smaller, frequent tests throughout the development stages, enabling immediate validation and system improvements.

  • Test Automation: Automating tests where possible and ramping up test coverage can speed up and enhance the testing process.

  • Prevention over Reaction: Focus on preventing problems rather than fixing them. Testers and developers can pair up, contribute to code, run tests pre-build, join discussions, ask questions, and provide rapid feedback to influence development decisions.

  • Team Collaboration: This Agile methodology thrives in cross-functional teams with extensive collaboration and a broad range of skills. Testers are involved in development and developers in testing, resulting in a product built with testability in mind.

Employ Formal Technical Reviews

Formal Technical Reviews (FTRs) can play a crucial role in software development by detecting logical and functional errors in early stages. These are structured group meetings where participants with defined roles ensure the software meets predefined standards and requirements.

When Should FTR be Done?

Ideally, an FTR should be conducted when the product has reached a certain level of maturity, but this may vary depending on the type of review.

Roles in FTR:

A typical FTR involves a team of engineers who perform specific roles – presenters, reviewers, or recorders.

FTR Report:

At the end of the FTR meeting, a review report is prepared, answering the following questions::

  • What was reviewed?

  • Who reviewed it?

  • What findings were made?

  • What decisions were taken?

Types of FTR:

  • Formal Review: The product author gives a presentation to introduce the product to the rest of the reviewers. The aim is to get the product accepted, suggest modifications if any, and discuss timelines.

  • Walkthrough: The reviewers examine the product’s source code, design, and documented requirements to find bugs. The code author is often present to answer any questions.

  • Inspection: While formal reviews and walkthroughs focus on bug detection, inspections are conducted to either expand initial standards or verify if previous bugs have been resolved.

Effective bugs report

A stellar bug report can cut through the confusion, spotlight the problem, and set you on the path to resolution.

How do you draft a top-notch bug report? Here’s your guide:

  • Be solution-oriented – don’t just outline the problem, propose a solution. Guide the developer through the ideal feature behavior.

  • Replicate before reporting, making sure the bug is a persistent troublemaker. Lay out a simple, step-by-step guide to recreating it. Even occasional glitches are worth noting.

  • Be crystal clear about what you see and what you expect to see. Put it all down – the good, the bad, and the glitchy. Remember, one problem per report keeps confusion at bay.

  • Screenshot it – a picture paints a thousand words, especially for bugs. Highlight the issue to give engineers a visual guide.

  • Summarize smartly, capturing the essence of the bug – it will make identifying and searching for bugs as easy as ABC.

Maximize your test management tools

Professional test management tools can effectively streamline and structure your testing process, hooking you up with test automation frameworks, CI/CD tools, bug tracking systems, and more.

Some of the popular platforms are:

  • Zephyr: A global leader in test management solutions that supports Agile and DevOps frameworks, including Zephyr for Jira, Zephyr Scale, and Zephyr Enterprise to sync multiple teams.

  • SpiraTest: Robust QA suite to effortlessly manage your defects and requirements, with full traceability, support for various test types, and an array of report options.

  • TestRail: A comprehensive solution with powerful integration options that can track your test results and metrics on customizable dashboards for actionable insights.

  • Kualitee: A flexible tool for defect and test case management, with comprehensive reporting, integrated with various testing systems.

  • Testpad: Easy-to-use tool, perfect for professional testers, managers, and clients, helping in creating checklist-based test plans, adding new tests on the fly, and adapting to various testing styles.

Continuous Feedback and Iterative Improvement: The Heartbeat of QA

In the dynamic landscape of software development, the adoption of continuous feedback and iterative improvement mechanisms stands as a cornerstone for quality assurance (QA) excellence. This chapter delves into how embedding these practices within the QA process can significantly elevate the quality of software products, ensuring they not only meet but exceed the evolving expectations of users and stakeholders.

Embracing Continuous Feedback

Continuous feedback involves the regular collection and analysis of feedback from all stakeholders involved in the software development lifecycle, including developers, QA teams, end-users, and clients. This collaborative approach fosters a culture of openness and adaptability, where insights and suggestions are valued and swiftly acted upon. By integrating continuous feedback mechanisms, such as user acceptance testing (UAT) and beta testing, QA teams can uncover insights that may not be evident during the initial testing phases.

  • Feedback Loops with Development Teams: Creating a seamless feedback loop between QA teams and the development team ensures that any issues identified can be quickly addressed, reducing the turnaround time for bug fixes and enhancements. The role of the QA team lead is pivotal in facilitating this dialogue, ensuring that feedback is constructive and aligned with the project’s quality goals.

  • Engaging End-Users Early and Often: Involving end-users in the testing process through beta tests or early access programs allows QA teams to gather real-world feedback on the software’s performance, usability, and features. This user-centric approach helps in fine-tuning the product to better meet user needs and expectations.

The Power of Iterative Improvement

Iterative improvement, a principle closely tied to agile software development methodologies, emphasizes the continuous evolution of software products through repeated cycles of testing, feedback, and enhancements. This approach allows QA teams and the development team to make incremental improvements to the software, thereby enhancing its quality, functionality, and user satisfaction over time.


  • Agile and Scrum Frameworks: Implementing agile methodologies, such as Scrum, enables teams to work in sprints, focusing on delivering specific features or improvements in short, manageable cycles. This structure supports iterative development and testing, allowing QA teams to systematically address and refine each aspect of the software.

  • Continuous Integration and Continuous Deployment (CI/CD): Leveraging CI/CD practices allows for the automation of testing and deployment processes, facilitating the rapid integration of changes and ensuring that the software remains in a releasable state at all times. For QA teams, this means being able to test and validate changes more frequently and efficiently, significantly reducing the risk of major issues at later stages.

  • Regular Retrospectives: Conducting regular retrospective meetings with QA teams, the development team, and stakeholders offers a structured way to reflect on what worked well and what could be improved. These sessions encourage a culture of continuous learning and improvement, ensuring that lessons learned are incorporated into future iterations of the software development process.

Summing up

In the intricate world of software development, a robust and well-integrated QA process stands as a beacon, safeguarding the product’s integrity and end-user satisfaction. We’ve journeyed through the disastrous tales of neglected QA, emphasizing the dire need to prioritize software quality at every phase. Understanding and differentiating between the three crucial areas of software quality – assurance, control, and testing – form the bedrock of any successful digital product. Leveraging methodologies such as extreme programming, early and often testing with a shift-left approach, and the meticulous implementation of Formal Technical Reviews demonstrates the depth and breadth of considerations required. The potency of a clear bug report and the value of test management tools further augment the QA process, bridging gaps between expectations and deliverables. In essence, to transcend the challenges of today’s fast-paced software development landscape, it is paramount to embed a rigorous QA methodology from the project’s conception to its culmination. Remember, great products aren’t just born; they are thoroughly tested, refined, and perfected.