Mykhailo Ralduhin

Written by: Senior QA Engineer

Mykhailo Ralduhin

Updated: 12.10.2026

18 min read

A strong QA team is not simply a group of testers waiting for developers to finish a feature. It is a quality engineering function that helps the product team identify risks early, automate repeatable checks, validate the user experience, and understand what happens after a release reaches production.

This matters even more as development accelerates. According to the 2025 DORA Report, 90% of surveyed technology professionals use AI at work and more than 80% report productivity gains. At the same time, DORA found that greater AI adoption still has a negative relationship with software delivery stability. More code can be produced faster, but somebody must verify whether that code is secure, maintainable, observable, and suitable for real users.

Building an effective QA team therefore starts with product risk – not with an arbitrary tester-to-developer ratio.

A brief overview of QAOps

QAOps integrates quality assurance into development and operations workflows so that testing, monitoring, and feedback run continuously rather than at the end of a release. Our complete QAOps guide explains the model, process, benefits, and implementation in detail. Here, we will focus specifically on how to build the team responsible for making that approach work.

How to build a QA team: start with product risk

There is no universally correct QA team structure. Two products with the same number of developers may need completely different quality engineering capabilities.

A marketing website with monthly releases may be covered by one versatile QA engineer. A financial platform with real-time transactions, mobile apps, external APIs, and regulatory requirements may need functional testers, automation engineers, performance specialists, and access to security expertise.

Before opening QA positions, answer five questions:

1.

What would hurt the business most if it failed?
Identify revenue-critical, safety-critical, compliance-sensitive, and reputation-sensitive functionality.

2.

How frequently does the product change?
Frequent releases increase the value of test automation, stable environments, and fast CI feedback.

3.

Which platforms must be covered?
Web, mobile, desktop, APIs, embedded systems, and third-party integrations require different skills and infrastructure.

4.

Where are defects currently discovered?
Problems found mainly in production usually indicate gaps in requirements review, integration testing, regression coverage, or observability.

5.

What is slowing releases down?
The constraint may be manual regression, unstable test data, unreliable environments, flaky automation, or unclear ownership – not necessarily a shortage of testers.

The answers define the capabilities you need. Headcount comes later.

Choose the right QA team model

The team model determines how closely QA engineers work with developers, how knowledge is shared, and who owns common testing infrastructure.

QA team model
How it works
Best suited for
Main risk

Embedded QA

QA engineers work directly inside product squads

Products with independent cross-functional teams

Standards and tools may diverge between squads

Centralized QA

One QA department supports multiple development teams

Smaller organizations or products requiring consistent governance

QA can become a release gate and feedback may arrive late

Federated or hybrid QA

QA engineers are embedded in squads, while a central group maintains standards and infrastructure

Growing SaaS platforms and multi-team products

Responsibilities must be defined carefully

Dedicated QA team

A stable internal or external team is assigned to one product or product area

Companies that need long-term expertise and scalable QA capacity

The team may become isolated if collaboration is poorly designed

Specialist pool

Performance, security, accessibility, or test infrastructure experts support several teams

Organizations with occasional demand for deep expertise

Specialists can become bottlenecks

For many growing products, the hybrid model works well. Product squads receive day-to-day QA support, while a smaller central function owns automation architecture, test environments, quality standards, and reusable tooling.

The important point is that QA engineers must participate in delivery—not receive completed work over a virtual wall.

Essential roles in a modern QA team

Not every company needs to hire every role separately. A senior engineer may cover several responsibilities in an early-stage product. As the system and team grow, those responsibilities usually need clearer ownership.

Role
Primary responsibility
When it becomes important

QA lead or QA manager

Quality strategy, priorities, staffing, processes, and stakeholder communication

When multiple engineers or product teams need coordination

Manual or exploratory QA engineer

Functional validation, exploratory testing, usability checks, and risk discovery

From the first production-ready version

Test automation engineer or SDET

Automated checks, frameworks, CI integration, and test maintainability

When regression effort or release frequency starts growing

API and integration test engineer

Service contracts, data flows, integrations, queues, and failure handling

For distributed systems and integration-heavy products

Performance engineer

Load models, bottleneck analysis, capacity validation, and resilience testing

For high-traffic, real-time, or resource-intensive systems

Security testing specialist

Vulnerability assessment and security-focused validation

For products handling financial, health, identity, or sensitive customer data

Test infrastructure or QAOps engineer

Test environments, pipeline execution, test data, reporting, and observability

When automation runs continuously across several services or teams

Domain specialist

Business-rule validation and regulatory or industry-specific knowledge

In banking, healthcare, insurance, logistics, and other complex domains

QA lead

The QA lead should do more than distribute testing tasks. This person translates product and engineering risks into a practical quality strategy.

Typical responsibilities include:

  • defining the scope and depth of testing;

  • choosing appropriate quality gates;

  • deciding what should and should not be automated;

  • coordinating environments and test data;

  • setting useful quality metrics;

  • coaching engineers;

  • communicating release risks to product and engineering leaders.

A QA lead also protects the team from two common extremes: trying to automate everything and relying on manual regression for too long.

Manual and exploratory QA engineer

Manual QA remains valuable where human judgment is required. Exploratory testing can uncover confusing workflows, inconsistent behavior, unexpected state transitions, and usability problems that scripted checks may miss.

This role is particularly useful for:

  • new or rapidly changing functionality;

  • complex user journeys;

  • mobile and cross-device behavior;

  • visual and usability validation;

  • unusual combinations of actions;

  • ambiguous business rules.

The goal is not to execute the same checklist indefinitely. Repeatable, stable, high-value checks should gradually move into automation, leaving more time for exploration and product analysis.

Test automation engineer or SDET

An automation engineer builds software that tests software. That requires programming, debugging, architecture, and CI/CD skills – not only familiarity with a testing tool.

The role commonly covers:

  • API, UI, integration, and component test automation;

  • framework design and maintenance;

  • parallel and cross-platform execution;

  • test reporting;

  • flaky-test investigation;

  • pipeline integration;

  • test data creation;

  • collaboration with developers on testability.

An experienced SDET should also know when an end-to-end test is the wrong solution. Many conditions can be checked faster and more reliably at the API, component, contract, or unit level.

Test infrastructure or QAOps engineer

As automation grows, execution infrastructure becomes a product of its own. Someone must manage runners, containers, environments, secrets, test data, reports, and connections to monitoring systems.

This responsibility may belong to an SDET, platform engineer, or dedicated QAOps specialist. What matters is that ownership is explicit. Otherwise, teams accumulate slow pipelines, unreliable environments, and thousands of automated tests that nobody trusts.

Skills a QA team needs in 2026

Hiring only for knowledge of Selenium, Playwright, Appium, or another specific tool creates a fragile team. Tools change; engineering fundamentals and analytical skills travel between technology stacks.

Product and domain understanding

QA engineers should understand why a feature exists, who uses it, and what business damage a failure could cause. That knowledge helps them prioritize meaningful scenarios rather than maximize the number of test cases.

A tester working on a payment flow, for example, must think beyond whether a button works. They should consider duplicate transactions, delayed provider responses, currency rounding, failed callbacks, interrupted sessions, refund states, and reconciliation.

Programming and automation

At least part of the QA team should be comfortable with the product’s main programming language or a language that integrates well with the delivery stack. Engineers need to review code, work with APIs, manage dependencies, read logs, and build maintainable test utilities.

AI-assisted testing is becoming part of that skill set, but it does not remove the need for engineering judgment. The World Quality Report 2025–26 found that 63% of respondents considered generative AI an important quality engineering skill, while 60% highlighted core QE skills and 51% emphasized written and verbal soft skills. The same report found that 60% of organizations struggle with secure, scalable test data – an issue that cannot be solved by generating more test scripts.

CI/CD and cloud knowledge

A QA team working within QAOps should understand:

  • pipeline stages and triggers;

  • containers and ephemeral environments;

  • build artifacts;

  • feature flags;

  • deployment strategies;

  • cloud services;

  • secret management;

  • service dependencies;

  • rollback and recovery workflows.

The team does not need to replace DevOps or platform engineering. It does need enough knowledge to integrate testing into delivery without creating a slow, opaque pipeline.

API and data skills

Modern applications depend on APIs, databases, message queues, and third-party services. QA engineers should be able to inspect requests, validate schemas, query test data, trace events across services, and distinguish a frontend symptom from a backend cause.

Useful competencies include SQL, HTTP, REST or GraphQL, contract testing, message-based architecture, and controlled test-data generation.

Observability

Testing should not stop at deployment. Production telemetry can reveal slow endpoints, failed integrations, resource exhaustion, and user journeys that behave differently under real conditions.

Grafana’s 2025 Observability Survey found that 95% of surveyed organizations use metrics, 87% use logs, and 57% use traces. A modern QA team should know how to work with these signals, even when the observability platform itself is managed by another group.

Communication and influence

QA engineers routinely deliver unwelcome information: a release carries risk, an acceptance criterion is unclear, or a deadline cannot be met without reducing coverage. They must communicate those points without becoming perceived as an obstacle.

Strong QA communication is specific and decision-oriented. Instead of saying “testing is incomplete,” the engineer should explain:

  • which scenarios remain untested;

  • why they matter;

  • what evidence is available;

  • what could happen in production;

  • whether the risk can be reduced;

  • who should accept the remaining risk.

How large should a QA team be?

A fixed QA-to-developer ratio is tempting because it makes workforce planning easy. It is also frequently misleading.

Team size should reflect product risk, architecture, automation maturity, release frequency, and the amount of specialist work required.

Early-stage product

A small product team may start with one experienced, hands-on QA engineer. This person should be capable of exploratory testing, API validation, lightweight automation, and process design.

The first QA hire should usually be a generalist who can create a sensible foundation – not a junior tester who needs a mature system around them.

Growing SaaS product

As the roadmap expands, a typical QA function may include:

  • a QA lead;

  • functional or exploratory QA engineers assigned to product areas;

  • at least one automation-focused engineer;

  • shared access to performance and security expertise.

At this stage, the main challenge is preventing regression effort from growing at the same rate as the product.

Multi-product or regulated organization

Larger environments often need embedded QA engineers supported by centralized automation, test infrastructure, performance, security, and compliance capabilities.

The central group should provide reusable services and standards. It should not become an approval committee through which every release must pass.

A step-by-step process for building a QA team

1. Create a product risk map

List the system’s critical workflows, integrations, data assets, platforms, and regulatory obligations. Score them by likelihood of failure and potential impact.

This map becomes the basis for hiring priorities and test coverage.

2. Audit the existing delivery process

Review how requirements are refined, code is reviewed, builds are created, environments are provisioned, releases are approved, and incidents are analyzed.

Look for delays, duplicated work, missing ownership, and stages where defects repeatedly escape.

3. Define quality ownership

Developers should own code-level quality. Product managers should own acceptance criteria and product decisions. QA engineers should provide risk analysis, independent investigation, test design, and quality engineering expertise.

“QA owns quality” is usually a sign that everybody else has been allowed to stop owning it.

4. Select the team model

Choose embedded, centralized, hybrid, or dedicated QA based on how the engineering organization works. Define reporting relationships, decision rights, and ownership of shared infrastructure before hiring.

5. Hire for the largest current constraint

If releases are blocked by manual regression, hire automation expertise. If requirements are consistently misunderstood, prioritize a senior product-oriented QA engineer. If environments are unreliable, add test infrastructure or platform skills.

Do not hire five people with the same profile simply because that profile is easiest to recruit.

6. Establish a layered testing approach

Distribute checks across unit, component, API, contract, integration, UI, and exploratory levels. Reserve expensive end-to-end tests for critical workflows that genuinely require the complete system.

The team should optimize for useful feedback, not the largest possible automated suite.

7. Integrate feedback into delivery

Automated checks should run at the stage where their results are actionable. Fast checks can run on pull requests, broader integration tests after deployment to a test environment, and selected smoke checks after production deployment.

A pipeline that reports a failure two hours after the developer has moved to another task is technically automated but operationally weak.

8. Review and scale deliberately

As the product changes, reassess whether the team still has the right mix of domain, automation, performance, security, and infrastructure skills. Scale around emerging risks rather than automatically matching developer headcount.

When a dedicated QA team makes sense

A dedicated QA team is a stable group assigned to one product, platform, or long-term program. It can be built internally or provided by an external quality engineering partner.

This model is useful when:

  • the internal team lacks specialized QA expertise;

  • regression work has become a release bottleneck;

  • several platforms or product modules require continuous coverage;

  • the company needs automation, performance, or mobile testing skills quickly;

  • hiring locally would delay the roadmap;

  • product knowledge must stay within a stable team;

  • QA demand is long-term but the required mix of skills may change.

A dedicated team should operate as part of the engineering organization. Its members need access to planning sessions, architecture discussions, code repositories, environments, incident reviews, and product analytics. Giving an external team only completed builds and lists of requirements recreates the same QA silo that QAOps is intended to remove.

When evaluating a provider, ask:

  • Who owns the QA strategy and framework?

  • How is product knowledge documented and retained?

  • Can the team adjust its skill mix as the product evolves?

  • How are seniority levels verified?

  • Who investigates flaky tests and environment failures?

  • What reporting will product and engineering leaders receive?

  • Who owns the automation code and test assets?

  • How will knowledge be transferred if the engagement ends?

If you need a stable group that can integrate with your developers and scale with the roadmap, DeviQA can assemble a dedicated QA team with the required functional, automation, performance, and QA leadership capabilities.

How to measure QA team effectiveness

Avoid measuring individual testers by the number of test cases written, bugs reported, or automated scripts created. Those metrics reward activity and are easy to manipulate.

Use a balanced set of product, delivery, and testing indicators instead.

Metric
What it shows
Warning sign

Escaped defect rate

How many relevant defects reach users

Repeated growth in high-impact production issues

Defect removal efficiency

How effectively problems are found before release

More defects discovered after deployment than during development

Feedback time

How quickly engineers receive useful test results

Pipeline feedback arrives after work has moved on

Flaky-test rate

Whether automation can be trusted

Teams rerun failures instead of investigating them

Critical-flow coverage

Whether important journeys have sufficient protection

High automation numbers but weak coverage of revenue-critical behavior

Regression duration

How quickly release risk can be assessed

Regression time grows with every sprint

Change failure rate

How often deployments require intervention

Release speed rises while stability declines

Deployment rework rate

How often unplanned deployments are needed to fix incidents

Frequent hotfixes or corrective releases

Mean time to detect

How quickly failures are recognized

Customers report problems before internal monitoring does

Reopened defect rate

Whether fixes address root causes

The same problems repeatedly return

The current DORA software delivery metrics include change lead time, deployment frequency, failed deployment recovery time, change fail rate, and deployment rework rate. DORA recommends applying these metrics to an individual application or service and warns against turning them into simplistic targets or comparisons between unrelated teams.

QA metrics should lead to a decision. If nobody knows what action a number should trigger, it is probably reporting noise.

A practical 30-60-90-day QA team plan

Period
Priorities
Expected outcomes

First 30 days

Map risks, interview stakeholders, review incidents, audit regression coverage, inspect environments and pipelines

Shared view of the largest product and delivery risks

Days 31–60

Define ownership, choose the team model, establish test levels, stabilize critical checks, create baseline metrics

Clear QA operating model and initial fast feedback

Days 61–90

Expand high-value automation, improve test data and environments, add production feedback, address skill gaps

Repeatable quality process connected to delivery

After 90 days

Review trends, remove low-value tests, reduce pipeline friction, scale specialist capabilities

Continuous improvement based on evidence

Do not spend the first three months building an enormous framework before testing real risks. Start with one or two critical workflows, prove that the feedback is reliable, and then expand.

Common mistakes when building a QA team

Hiring only manual testers

Manual testing is important, but a team without sufficient technical depth will struggle to keep pace with continuous delivery. Ensure the team can work with APIs, automation, pipelines, logs, and data.

Expecting one engineer to cover every specialty

A senior generalist may establish the function, but functional, automation, performance, security, and infrastructure work require different depths of expertise. Shared specialists are often more realistic than expecting one person to master everything.

Treating QA as the final release gate

When QA receives features only after implementation, defects are discovered at the most expensive and disruptive point. QA engineers should contribute during refinement, architecture discussions, and risk assessment.

Automating without a maintenance model

Every automated test creates an ongoing obligation. The team must know who reviews failures, removes obsolete checks, updates dependencies, and keeps the suite fast.

Using coverage numbers without context

A product can have thousands of automated tests and still fail in its most important workflow. Coverage must be connected to product risk.

Ignoring test environments and data

Automation will not create fast feedback if environments are unstable or data cannot be prepared safely. These capabilities need owners, budgets, and measurable service expectations.

Separating QA from production feedback

A team that never reviews incidents, logs, support tickets, and product analytics will continue testing assumptions instead of actual user risks.

Final thoughts

Building a QA team is an organizational design problem before it is a recruitment problem. The objective is not to create a separate department responsible for catching everybody else’s mistakes. It is to give the product organization the skills, infrastructure, and feedback loops required to make informed release decisions.

Start with the risks that matter to users and the business. Choose a team model that fits how development actually works. Combine product knowledge with automation, infrastructure, data, and communication skills. Then measure whether the team is improving feedback speed and production outcomes – not merely increasing testing activity.

That is what turns a group of testers into an effective quality engineering team.

See how your QA could grow with you

Mykhailo Ralduhin

About the author

Mykhailo Ralduhin

Senior QA engineer

Mykhailo Ralduhin is a Senior QA Engineer at DeviQA, specializing in building stable, well-structured testing processes for complex software products.