QA interview questions usually cover testing fundamentals, test-case design, bug handling, regression, automation, risk and real-world judgment.
Junior candidates are expected to explain core concepts clearly, while mid-level and senior QA interviews increasingly focus on prioritization, automation decisions, release risk and quality strategy.
This guide contains 40 QA interview questions with model answers, split by experience level:
Each answer includes the level of thinking an interviewer is usually looking for.
If the role includes automation, also review the Automation Testing Tutorial and QA Automation before the interview.
- Before the interview: prepare four real stories
- Junior QA interview questions
- 1. What is Quality Assurance?
- 2. What is the difference between QA, QC and testing?
- 3. What is a bug?
- 4. What is the difference between severity and priority?
- 5. What is verification vs validation?
- 6. What is a test case?
- 7. What is the difference between a test scenario and a test case?
- 8. What is positive testing?
- 9. What is negative testing?
- 10. What is regression testing?
- 11. What is smoke testing?
- 12. What is the difference between smoke and sanity testing?
- 13. What is functional testing?
- 14. What is non-functional testing?
- 15. What is exploratory testing?
- Mid-level QA interview questions
- 16. How do you decide what to test first?
- 17. How do you write a good bug report?
- 18. What do you do if a developer says “It's not a bug”?
- 19. What is boundary value analysis?
- 20. What is equivalence partitioning?
- 21. What is a test plan?
- 22. What is the difference between a test plan and test strategy?
- 23. How do you estimate testing effort?
- 24. When should a test be automated?
- 25. What should not be automated?
- 26. What is the test pyramid?
- 27. What is end-to-end testing?
- 28. What is integration testing?
- 29. How do you handle flaky automated tests?
- 30. How do you test when requirements are incomplete?
- Senior QA interview questions
- 31. How would you create a test strategy from scratch?
- 32. How do you decide whether a release is ready?
- 33. What QA metrics do you track?
- 34. How do you measure automation ROI?
- 35. How would you reduce a two-hour regression suite?
- 36. How should QA work in Agile teams?
- 37. Who owns quality?
- 38. How would you introduce automation into a team with no automation?
- 39. What would you do if developers resisted QA involvement?
- 40. How is AI changing QA?
- Common QA scenario questions
- Manual QA vs automation interview questions
- QA interview practical tasks you may receive
- Questions to ask at the end of a QA interview
- QA interview preparation checklist
- Final QA interview advice
Before the interview: prepare four real stories
Definitions help, but interviewers remember examples.
Prepare one short story for each of these:
- a bug you found that mattered
- a test you designed from scratch
- a time you disagreed with a developer or product owner
- a testing process you improved
Use concrete details.
Instead of:
I worked on regression testing.
say:
I maintained a regression suite covering our checkout and account flows. Before each release I reviewed failures, removed duplicate cases and added coverage for production defects from the previous sprint.
You don't need dramatic numbers.
You need evidence that you've actually thought about quality.
Junior QA interview questions
1. What is Quality Assurance?
Quality Assurance, or QA, is the process of improving how software is built so defects are prevented or detected before users encounter them.
QA is broader than executing test cases.
It can include:
- requirements review
- test planning
- risk analysis
- manual testing
- automation
- defect analysis
- process improvement
A good answer shows that quality isn't something a tester “adds” after development. QA helps the whole team build software more reliably.
What the interviewer is checking: Whether you understand QA as a process, not simply clicking through an application.
2. What is the difference between QA, QC and testing?
QA is process-focused and preventive.
Quality Control, or QC, is product-focused and checks whether the output meets expectations.
Testing is one activity used to identify defects and evaluate software behavior.
A simple way to remember it:
QA → How do we prevent quality problems? QC → Does the product meet quality expectations? Testing → What happens when we execute and inspect the product?
In practice, companies often use the terms less formally, so explain the distinction without getting stuck on terminology.
3. What is a bug?
A bug is a difference between expected and actual software behavior.
For example:
Expected: Clicking Save updates a customer's address.
Actual: The page displays a success message, but the old address remains after refresh.
A strong bug report should make that discrepancy reproducible.
Include:
- environment
- steps
- expected result
- actual result
- evidence
- severity where relevant
For the full workflow after a bug is reported, see Bug Life Cycle.
4. What is the difference between severity and priority?
Severity describes how badly a defect affects the system.
Priority describes how urgently the business wants it fixed.
For example, a typo in a homepage promotion may have low technical severity but high priority if a major campaign starts today.
A crash in an obscure internal screen could have high severity but lower immediate priority if the feature is almost never used.
The important point is that severity and priority answer different questions.
5. What is verification vs validation?
Verification asks:
Are we building the product correctly according to its specification?
Validation asks:
Are we building the product users actually need?
Verification can include reviews, requirement checks and design inspection.
Validation often involves executing the software and confirming that real behavior satisfies expected use cases.
A system can technically satisfy a specification and still fail users if the specification itself is wrong.
6. What is a test case?
A test case describes a condition or scenario that should be verified.
It usually contains:
- ID
- title
- preconditions
- steps
- expected result
- actual result
- status
Example:
Test: User logs in with valid credentials.
Expected: Dashboard opens and authenticated session is created.
For a ready structure, see the Test Case Template.
7. What is the difference between a test scenario and a test case?
A test scenario describes what should be tested at a high level.
Example:
Test the login functionality.
A test case describes exactly how to test one condition.
Example:
Enter a registered email and valid password, click Sign In, then verify that the dashboard appears.
One scenario usually produces several test cases:
- valid login
- invalid password
- unknown account
- empty fields
- locked account
8. What is positive testing?
Positive testing verifies that valid input produces the expected successful result.
Example:
Enter valid credentials and confirm that login succeeds.
Positive tests are important because they prove the intended happy path works.
They aren't enough by themselves.
Most real systems also need negative, boundary and failure-state testing.
9. What is negative testing?
Negative testing checks how the system behaves when input or conditions are invalid.
Examples include:
- wrong password
- expired card
- unsupported file
- quantity above available stock
- missing required field
A good negative test doesn't simply expect “failure.”
It verifies that the system fails safely and clearly.
For example, an invalid payment shouldn't create a paid order.
10. What is regression testing?
Regression testing checks whether recent changes broke functionality that previously worked.
For example, changing checkout tax calculations might require regression coverage around:
- cart totals
- promo codes
- shipping
- payment
- order confirmation
Regression suites usually focus on important, stable behavior rather than rerunning every historical test after every change.
See What Is Regression Testing? for the full methodology.
11. What is smoke testing?
Smoke testing is a small set of high-priority checks used to determine whether a build is stable enough for further testing.
A web-app smoke suite might verify:
- homepage loads
- login works
- dashboard opens
- one core action succeeds
Smoke tests should be fast and broad rather than deep.
If smoke fails, the build may not be worth testing further.
See What Is Smoke Testing? for examples and automation patterns.
12. What is the difference between smoke and sanity testing?
Smoke testing checks whether the major parts of a build work well enough for further testing.
Sanity testing usually checks a smaller area after a specific change or fix.
Example:
Smoke: Login, dashboard and checkout all open.
Sanity: A recently fixed coupon rule now works correctly.
Terminology varies between organizations, so explain the intent rather than insisting every company uses the labels identically.
13. What is functional testing?
Functional testing verifies what the software does against expected business behavior.
Examples include:
- user can create an account
- password reset sends the correct email
- cart total updates after quantity changes
- payment failure doesn't create a paid order
Functional testing can be manual or automated and can occur at API, UI or other layers.
See Functional Testing.
14. What is non-functional testing?
Non-functional testing checks characteristics of the software rather than one specific business function.
Examples include:
- performance
- security
- usability
- accessibility
- reliability
- compatibility
For example, functional testing asks:
Does checkout work?
Performance testing asks:
Does checkout remain responsive when many users are active?
Both matter, but they answer different questions.
15. What is exploratory testing?
Exploratory testing combines learning, test design and execution.
Instead of following only predefined cases, the tester actively investigates the product and adapts based on what they observe.
A useful exploratory session might focus on:
What happens if the user changes cart contents in multiple tabs during checkout?
Exploratory testing is particularly valuable for new features, unusual interactions and areas where predefined cases may not cover every risk.
Mid-level QA interview questions
16. How do you decide what to test first?
I prioritize by risk.
I usually consider:
- customer impact
- revenue impact
- frequency of use
- recent code changes
- technical complexity
- history of defects
- recoverability if something fails
For an ecommerce release, I'd normally prioritize checkout and payment over cosmetic profile settings.
When time is limited, QA should explain what was tested, what wasn't and what risk remains instead of pretending full coverage was achieved.
17. How do you write a good bug report?
A good bug report lets another person reproduce and understand the problem quickly.
I include:
- descriptive title
- environment/build
- preconditions
- short numbered steps
- expected behavior
- actual behavior
- screenshot/video/logs where useful
- severity and relevant context
I avoid assumptions about root cause unless I've verified them.
For example, I would write:
POST /checkout returned HTTP 500
instead of:
Database is broken.
The first is evidence. The second may be speculation.
18. What do you do if a developer says “It's not a bug”?
First I compare the behavior with:
- requirements
- acceptance criteria
- design
- previous behavior
- agreed product rules
If the requirement is unclear, I involve the relevant product owner rather than turning the issue into a personal disagreement.
Sometimes the developer is right.
Sometimes QA identified an unclear requirement.
Sometimes the observed behavior technically matches a specification but creates a serious user problem.
The goal is to reach a shared decision about expected behavior.
19. What is boundary value analysis?
Boundary value analysis focuses testing around the edges of allowed ranges because defects often appear near limits.
Suppose a field accepts quantities from 1 to 100.
Useful values include:
- 0
- 1
- 2
- 99
- 100
- 101
You don't need to test every number from 1 to 100 to discover many common validation mistakes.
Boundary testing is particularly useful for numeric fields, dates, lengths and resource limits.
20. What is equivalence partitioning?
Equivalence partitioning groups inputs that should behave similarly, then tests representative values from each group.
Suppose age must be between 18 and 65.
Partitions might be:
- below 18 → invalid
- 18–65 → valid
- above 65 → invalid
Instead of testing every possible age, you choose representative values from each partition and combine them with boundary testing where appropriate.
21. What is a test plan?
A test plan explains how a testing effort will be organized.
It may include:
- scope
- objectives
- test types
- environments
- roles
- schedule
- entry criteria
- exit criteria
- risks
The goal isn't documentation for its own sake.
A useful plan helps everyone understand what confidence the team intends to build before release.
See Software Test Plan.
22. What is the difference between a test plan and test strategy?
A test strategy is usually higher-level and describes the overall approach to quality.
A test plan is more specific to a project, release or initiative.
For example:
Strategy: Critical SaaS customer journeys should be protected by automated regression and API tests.
Plan: For Release 4.8, run 35 critical browser tests, checkout integration tests and a two-hour exploratory session before deployment.
Terminology differs between organizations, so focus on purpose and level of detail.
23. How do you estimate testing effort?
I estimate based on risk and scope rather than simply counting screens.
I consider:
- feature complexity
- number of integrations
- environments
- supported browsers/devices
- test data
- regression impact
- automation requirements
- uncertainty in requirements
I also separate:
- test design
- environment setup
- execution
- defect retesting
- regression
For unfamiliar features, I include contingency rather than pretending the estimate is exact.
24. When should a test be automated?
I automate when the test is:
- repeated often
- stable enough
- important
- time-consuming manually
- deterministic
- needed in CI/CD
Examples include login, checkout smoke flows and recurring regression checks.
I avoid automating unstable features too early or one-off scenarios where maintenance costs more than manual execution.
The goal isn't maximum automation percentage.
It's useful repeatable coverage.
See QA Automation for a practical prioritization model.
25. What should not be automated?
Good candidates for manual or exploratory testing include:
- rapidly changing prototypes
- subjective usability judgments
- one-time checks
- scenarios that depend on human perception
- tests with very high maintenance and little repeat value
Automation is strongest for repeatable, deterministic behavior.
If maintaining the script repeatedly costs more than executing the test manually, automation may not be justified yet.
26. What is the test pyramid?
The test pyramid is a model suggesting that most automated checks should exist at faster lower layers, with fewer tests at expensive UI layers.
A typical shape is:
Many unit tests Some integration/API tests Fewer E2E tests
It's not a mandatory numerical ratio.
Its value is economic.
If a pricing calculation can be validated in milliseconds at unit level, it doesn't need 40 browser tests.
See Unit Testing vs End-to-End Testing.
27. What is end-to-end testing?
End-to-end testing validates a complete workflow through multiple integrated parts of the application.
For example:
Login → product selection → checkout → payment → confirmation
An E2E test checks the complete outcome rather than one isolated service.
Because these tests involve more dependencies, they're generally slower and more expensive to maintain than lower-layer tests.
Use them for critical user journeys rather than every possible rule.
See End-to-End Testing.
28. What is integration testing?
Integration testing verifies whether two or more components communicate correctly.
Examples:
- application + database
- checkout + payment API
- service + message broker
- frontend + API
A component can work perfectly in isolation and still fail when integrated because of schema, authentication, state or timing problems.
BugBug's Integration Testing Tools guide explains which tools fit different integration boundaries.
29. How do you handle flaky automated tests?
I don't treat retries as the fix.
First I classify the cause:
- test logic
- selector
- timing
- test data
- shared state
- environment
- external dependency
- actual product defect
A persistently flaky test shouldn't remain a trusted release gate.
I would assign an owner, repair it and temporarily quarantine it if necessary.
30. How do you test when requirements are incomplete?
I make uncertainty visible early.
I would:
- identify missing decisions
- ask product/business owners specific questions
- document assumptions
- test what can already be validated
- prioritize areas where ambiguity creates the most risk
For example:
Should a user be able to stack two promo codes?
is much more useful than:
Requirements aren't clear.
QA often improves requirements simply by asking how edge cases should behave.
Senior QA interview questions
31. How would you create a test strategy from scratch?
I'd begin with product risk, not tools.
First I would understand:
- critical user journeys
- architecture
- customer impact of failure
- release frequency
- integrations
- production incidents
- team skills
Then I'd assign coverage to appropriate layers:
- unit
- API/integration
- browser
- exploratory
- non-functional
I'd define ownership, environments, CI/CD gates and metrics.
Only after that would I select tooling.
A strategy should explain where confidence comes from, not simply list frameworks.
Automate your tests for free
Test easier than ever with BugBug test recorder. Faster than coding. Free forever.
Get started
32. How do you decide whether a release is ready?
Release readiness is a risk decision, not simply “all tests passed.”
I would consider:
- critical test results
- known defects
- production impact
- regression scope
- monitoring/recovery ability
- unresolved uncertainty
- stakeholder acceptance
One low-priority defect might be acceptable.
One unexplained checkout failure probably isn't.
QA should communicate residual risk clearly so the relevant decision-maker can make an informed release decision.
33. What QA metrics do you track?
Useful metrics depend on the problem.
I may track:
- escaped defects
- reopen rate
- flaky-test rate
- regression duration
- automation execution time
- time to feedback
- defect detection stage
- production incident contribution
I avoid metrics that create bad incentives, such as number of bugs found per tester.
Metrics should help answer:
Where is our quality process failing?
See QA Metrics for a broader set.
34. How do you measure automation ROI?
I compare the cost of building and maintaining automation against the value it creates.
Inputs include:
- manual execution time saved
- release frequency
- test creation cost
- maintenance
- infrastructure
- reduced feedback time
- defects caught before production
Automation ROI shouldn't be measured only by test count.
A small suite protecting expensive customer journeys may create more value than thousands of low-risk scripts.
See Test Automation ROI.
35. How would you reduce a two-hour regression suite?
I wouldn't start by randomly deleting tests.
I'd analyze:
- duplicates
- obsolete cases
- tests at the wrong layer
- execution bottlenecks
- parallelization opportunities
- flaky cases
- high-value vs low-value coverage
Some browser checks may belong at API or unit level.
I might create:
10-minute smoke suite 30-minute critical regression 2-hour full nightly suite
The goal is faster feedback without blindly reducing confidence.
36. How should QA work in Agile teams?
QA should participate before development finishes.
That includes:
- refinement
- acceptance criteria
- risk analysis
- testability discussions
- test design
- automation planning
If QA begins only after a story moves to “Ready for Testing,” the team loses opportunities to prevent defects earlier.
This is one reason shift-left testing fits Agile and DevOps workflows well.
37. Who owns quality?
The whole delivery team owns quality, but responsibilities aren't identical.
Developers may own:
- unit tests
- implementation quality
- component checks
QA may specialize in:
- risk analysis
- exploratory testing
- system behavior
- test strategy
Product owns clarity around expected business behavior.
A shared-quality model doesn't mean removing QA expertise.
It means quality can't be handed to one person at the end of the sprint.
38. How would you introduce automation into a team with no automation?
I would start small.
First:
- identify 5–10 stable critical flows
- decide who will maintain them
- select a tool that matches team skills
- create a small smoke/regression suite
- connect it to the release workflow
- track failures and maintenance
I wouldn't begin with “automate 80% of all manual cases.”
The first objective is building a suite the team trusts.
The Automation Testing Tutorial shows a practical first-test workflow.
39. What would you do if developers resisted QA involvement?
I'd avoid framing it as QA needing more control.
Instead I'd show where earlier QA input saves engineering time.
For example:
We keep reopening stories because acceptance criteria don't cover error states. If we review these scenarios during refinement, developers get the expected behavior before implementation.
The goal is reducing rework.
I'd start with one workflow where collaboration clearly improves delivery rather than imposing a large new process.
40. How is AI changing QA?
AI is reducing the effort required for some repetitive tasks, including:
- generating candidate test cases
- producing automation
- analyzing failures
- maintaining selectors
- summarizing results
It doesn't automatically decide what behavior is correct.
QA still needs product context, risk judgment and validation of generated output.
An AI-generated test with the wrong expected result can create false confidence faster than manual testing.
For a longer answer, read our article on how AI is changing QA: as AI makes code cheaper to produce, the bottleneck moves from creating software to validating it.
See AI Testing Tools and Generative AI in Software Testing for the current tooling landscape.
Common QA scenario questions
Technical definitions are usually the easy part.
Scenario questions show how you reason when information is incomplete.
“You have two hours before release. What do you test?”
A strong answer prioritizes risk.
I would identify:
- what changed
- critical user journeys affected
- high-impact integrations
- recent defects
- areas with weak automated coverage
Then I'd run the fastest relevant automated suites and use the remaining time for focused exploratory testing.
I would also communicate what wasn't tested.
“A critical bug appears one hour before release. What do you do?”
First establish impact and reproducibility.
Then determine:
- affected users
- workaround availability
- fix risk
- regression scope
- rollback/release options
QA should provide evidence rather than make the business decision alone.
For a payment failure affecting all users, postponing release may be obvious.
For an obscure low-impact edge case, the decision could be different.
“A developer says the bug cannot be reproduced.”
I would compare:
- environment
- build
- data
- browser/device
- permissions
- timing
- logs
Then I'd try to reduce the scenario to the smallest reliable reproduction.
If it's intermittent, I'd capture additional evidence rather than repeatedly closing and reopening the report.
“A test passes locally but fails in CI. What do you check?”
I'd investigate differences in:
- environment
- test data
- browser/runtime version
- timing
- parallel execution
- network
- secrets/configuration
- shared state
A CI-only failure often exposes hidden dependencies the local test environment doesn't reveal.
“Would you release with failing automated tests?”
It depends on why they failed.
If a test proves a critical product defect exists, no.
If the test itself is known to be flaky and the relevant product behavior has been independently verified, the release decision may be different.
The important part is understanding the failure rather than treating green/red status as context-free truth.
Manual QA vs automation interview questions
Automation roles increasingly expect candidates to understand both.
| Question | Manual QA emphasis | Automation QA emphasis |
|---|---|---|
| Test design | Risk, scenarios, exploration | Repeatability and layers |
| Execution | Human investigation | Automated feedback |
| Debugging | Product behavior | Product + test code/infrastructure |
| Tools | Browser/dev tools, management | Playwright, Selenium, Cypress, no-code tools |
| CI/CD | Understand pipeline impact | Integrate and maintain tests |
| Ownership | Coverage and product risk | Coverage + automation architecture |
If you're applying for a hybrid QA role, be ready to explain why you would automate something rather than simply demonstrating that you can.
For tool comparisons, see Web Testing Tools and Test Automation Frameworks.
QA interview practical tasks you may receive
Write test cases for a login page
Expect to cover:
- valid login
- invalid password
- unknown user
- empty required fields
- lockout/throttling
- password reset
- session behavior
- basic security conditions
See Test Cases for Login Page for a fuller example.
Test an ecommerce checkout
Think beyond the happy path:
- cart totals
- stock
- coupons
- shipping
- payment success
- payment failure
- duplicate submission
- authorization
- mobile behavior
Our 80 Ecommerce Test Cases shows how this can be structured.
Find bugs on a test website
Interviewers may give you an unfamiliar application and ask you to explore it.
Before clicking randomly, identify:
- core workflow
- inputs
- boundaries
- navigation
- errors
- state changes
BugBug also maintains examples of Websites With Bugs for Testing if you want to practice.
Questions to ask at the end of a QA interview
The questions you ask can reveal seniority surprisingly well.
Useful options include:
What causes the most production defects today?
This tells you where the actual quality problem sits.
What does the current regression suite cover?
You'll learn whether testing is structured or mostly reactive.
Who owns automated tests when they fail?
This exposes automation ownership.
How early is QA involved in feature development?
You'll learn whether the team practices shared quality or relies on late handoffs.
What would you want the person in this role to improve during their first three months?
This gives you a concrete picture of the job rather than the generic job description.
QA interview preparation checklist
Before the interview, make sure you can explain without notes:
- QA vs QC
- verification vs validation
- severity vs priority
- smoke vs sanity
- regression
- functional vs non-functional testing
- unit vs integration vs E2E
- positive vs negative testing
- boundary values
- equivalence partitioning
For a mid-level role, also prepare examples of:
- prioritizing limited test time
- writing a useful bug report
- handling unclear requirements
- choosing automation candidates
- dealing with flaky tests
For a senior role, prepare:
- a test strategy
- release-risk decisions
- metrics you actually use
- automation ROI
- an example of improving a QA process
💡 Check also
Final QA interview advice
Don't memorize these answers word for word.
Interviewers can usually tell.
Use the structure, then add your own experience.
For example:
Regression testing verifies that a change hasn't broken existing behavior. In my current project, we split regression into a 12-minute critical suite for releases and a larger overnight suite.
The definition proves you know the concept.
The second sentence proves you've used it.
That's usually what separates a technically correct answer from a convincing one.
Last verified: October 2026.



