TL;DR: Quality assurance (QA) is about the process. It prevents defects by setting how software gets planned, built, reviewed and tested. Quality control (QC) is about the product. It finds defects by inspecting and testing the actual build before it ships. You need both, because poor software quality cost US organizations an estimated $2.41 trillion in 2022 (CISQ, The Cost of Poor Software Quality in the US, 2022). ContextQA Ship, the autonomous quality engineer, does QC on every pull request, so your QA process has evidence before code merges.
The qa vs qc debate comes down to timing. QA shapes the process so defects are less likely. QC inspects the build to catch the defects that get through anyway. When teams blur the two, CI pipelines fill up with flaky checks at the end of the cycle and nobody owns prevention. This guide covers which comes first, how the two differ, and what to change in your release process on Monday.
Quick answers
Which comes first in a software team, QA or QC? QA comes first. It sets up the process before any code is built: the definition of done, review rules, test strategy, and the checks that must pass before a merge. QC comes later and tests the finished build against that standard through test runs, defect triage, and release sign off. If you have QC without QA, you find the same defects every sprint and never fix why they keep appearing.
How should an engineering manager split ownership of QA and QC? Make QA a shared engineering job and give QC a clear owner. Leads and developers own the process: acceptance criteria, code review, testing on every pull request, and the rule that a red build blocks a merge. A QA lead or SDET owns the checks: regression suites, flaky test triage, defect reports, and the final go or no go call for a release.
What metrics show whether QA or QC is the weak link? Look at where defects get found. If many bugs escape to production or turn up late in staging, your QC checks are too thin. If the same kinds of defects come back after being fixed, your QA process is not fixing the root cause. Track defect escape rate, rework per sprint, and the share of failures that turn out to be flaky tests, and review the trend every release.
QA vs QC: What Is the Short Answer?
Quality assurance (QA) is the process-focused discipline that prevents defects by defining how software is planned, built, reviewed, and released. Quality control (QC) is the product-focused activity that finds defects in a specific build by inspecting and testing it. The difference matters because a QA gap makes the same bugs come back, and a QC gap lets them ship.
ISO 9000 draws a similar line. QA is the part of quality management focused on providing confidence that quality requirements will be fulfilled, and QC is the part focused on fulfilling quality requirements (ISO 9000:2015, Quality management systems: Fundamentals and vocabulary).
Software testing is the main QC technique: you run the code and compare what it does with what it should do. QA decides which tests exist and when they must pass. The two meet in the CI/CD pipeline. Branch protection is a QA decision, and the suite that runs behind it is QC.
For engineering leaders, here is a practical check. If escaped defects keep landing in the same category, you have a QA problem, and more test cases only treat the symptom.
How Do QA and QC Compare?
QA and QC differ in timing, goal, and ownership. Quality assurance (QA) is process work that prevents defects: standards, reviews, and test strategy. Quality control (QC) is product work that finds defects in a build that already exists: test runs, inspection, and release checks. QA asks whether the process is right. QC asks whether this build is right.
| Practice | Main goal | Typical owner | SDLC and CI/CD examples | Notable tradeoff |
|---|---|---|---|---|
| QA | Prevent defects | QA lead, engineering manager | Definition of done, review rules, test strategy, exit criteria | Slow payoff, hard to measure |
| QC | Detect defects | SDETs, developers, testers | Unit and end to end runs per pull request, regression suites, exploratory sessions | Bugs already exist when found |
| CI merge checks | Enforce both | DevOps, platform team | Required status checks, branch protection, merges blocked on failed suites | Flaky tests erode trust in the check |
Few SaaS teams have anyone with a "QC" job title. Developers own unit tests, SDETs own automated regression suites, the QA lead owns strategy and release criteria, and the engineering manager owns the process that ties them together.

When Should You Choose QA?
Choose QA when the problem is how your team builds software, not one bad release. Quality assurance is proactive and process oriented: it sets the standards, reviews, and pipeline checks that keep defects from being written. If the same kind of bug keeps escaping, or nobody owns test strategy, invest in QA before you add more inspection.
QA should come first in these situations:
- Repeat escapes: The same type of defect reaches production twice. QC catches the next one. QA asks why the process let it through, for example missing acceptance criteria or no contract test on an API.
- Shift left in Agile and DevOps: Short sprints and daily deploys leave no room for a separate test phase. QA moves checks earlier: testers join backlog refinement, acceptance criteria become test cases, and every pull request runs regressions before merge.
- Flaky pipelines: If engineers rerun failed jobs until they pass, the check has lost trust. Setting test ownership, quarantine rules, and retry policy is QA work.
- Growing teams: New squads need a shared definition of done before they need more testers.
When Should You Choose QC?
Choose QC when the risk is in a specific build and not in the process that produced it. That build might be a release candidate, a hotfix, or a bug a customer reported. QC checks the output and returns a pass or fail with evidence, so use it when you need to decide whether to ship or hold.
- Before a merge or release: CI regression suites, test automation frameworks, and test management tools that track executed cases and logged defects are QC tooling. Process audits, coding standards, and review checklists are QA tooling.
- When a defect is already reported: QC means reproducing the bug, confirming its root cause, and attaching proof.
- When every pull request changes the risk: Impact analysis (mapping a code change to the tests it affects) picks targeted regressions to run before merge, so you do not wait for a full nightly run.
- When escapes continue under a sound process: If your definitions of done and reviews hold up but defects still reach production, add QC depth before you rewrite the process.
How Do You Move Between Them?
Move from QC to QA by shifting checks earlier, one release at a time. Keep your end of cycle testing, add prevention at the pull request, then measure whether fewer defects escape. Most teams don't replace QC. They wrap it in a QA process, so inspection has less to catch because less goes wrong.
- Baseline your QC numbers. Before you change anything, record defect leakage (production defects divided by all defects found for a release) and escape rate per release. Without a baseline, you can't tell whether the change worked.
- Hire for the gap you have. A SaaS startup or agency that ships weekly with no tests needs a QA engineer first, someone who builds the pipeline and test strategy. Add QC testers once a stable product needs exploratory and acceptance checks on every release.
- Gate every pull request. Run targeted regressions on each change before merge, scoped by impact analysis to what the change touches.
- Close the loop on escapes. Reproduce each escaped bug from its Jira, Linear or Slack report and add a regression test for it.
- Track both metric sets. Coverage of critical flows and time to root cause measure QA. Defects found per cycle measures QC. If leakage falls while the QC count holds steady, the process is working.
If defects reach production because quality control only starts after merge, see how Ship tests every pull request before it lands: get started free, no credit card needed.

Where Does ContextQA Fit?
ContextQA Ship covers the quality control side of QA vs QC and feeds what it finds back into quality assurance. Ship tests every pull request, runs targeted regressions before merge, and reproduces reported bugs with evidence. Your team still owns the QA process: definitions of done, review rules and release criteria. Ship automates the inspection those rules call for.
Ship is its own self serve product for smaller product teams, separate from the ContextQA platform for enterprise application testing. Teams that need to test Salesforce or SAP workflows end to end use the platform's enterprise apps testing instead. Ship handles QC in three places:
- On every pull request: impact analysis finds the affected areas, and Ship runs targeted regressions on them before merge.
- On reported bugs: when someone reports a bug in Jira, Linear, Slack or a service desk, Ship reproduces it, finds the likely root cause and gives engineers the evidence.
- Back into QA: your leads review those root causes and change the process rules. People still make that call.
According to ship.contextqa.com (checked November 20, 2026), the free trial lasts 15 days and includes 3,000 credits with no payment card required. Paid plans start at Starter for $49 a month.
Bottom line
QA comes first: it sets the process, standards and test strategy before code is written. QC comes after, checking each finished build against those standards and catching what got through. They are not interchangeable. QA reduces the defects created, and QC finds the rest before release. Next, read what QA automation is and how an autonomous quality engineer handles test creation, execution and maintenance in your pipeline.
Sources
These are the primary sources behind the statistic and the definitions in this article. Each link goes to the publisher's own page, so you can check the figure, the year, and the exact wording before you cite them in your own quality documentation.