8 role-specific questions
QA Engineer Interview Questions & Answers
QA interviews test how you design tests systematically, what you automate and how you keep it reliable, how you test APIs and performance, and how you work inside an agile team.
Free, no sign-up. 71 questions in this role's practice pool, including behavioural, HR and situational questions.
QA & testing interview questions
Test design, automation, bug reporting, test strategy and quality in agile teams.
1.
Explain the different levels and types of testing.
BeginnerTechnicalPractise this question and get feedbackWhat the interviewer is evaluating
Testing fundamentals.
Key points a strong answer covers
- Unit. Unit tests check small pieces of code in isolation.
- Integration. Integration tests check that parts work together, e.g. API and database.
- System / E2E. System/end-to-end tests check full user journeys.
- Acceptance & non-functional. Acceptance, regression, smoke, performance, security and accessibility testing.
- Test pyramid. Many fast unit tests, fewer slow end-to-end tests.
Suggested answer structure
- Define it in one sentence.
- Explain how it works underneath.
- Give a practical example from code or a project.
- Close with a trade-off, pitfall or when you'd use it.
Common mistakes
- Treating QA as only manual UI testing.
- Not knowing the test pyramid.
Likely follow-up questions
- What's the difference between smoke and regression testing?
- Where does exploratory testing fit?
Example strong answer
Unit tests check individual functions or components in isolation and are fast and cheap. Integration tests check that pieces work together — an API with its database, or two services. System or end-to-end tests exercise complete user journeys through the real UI, like signing up and paying. User acceptance testing confirms the feature meets the business need. Across those, there are types: smoke tests to check a build is basically working, regression tests to make sure existing features still work, and non-functional testing — performance, security, accessibility, usability. The test pyramid says to have many unit tests, fewer integration tests and a small number of slow, brittle end-to-end tests, plus exploratory testing by people.
2.
How do you design test cases for a feature? Use a login form as an example.
IntermediateTechnicalPractise this question and get feedbackWhat the interviewer is evaluating
Systematic test design techniques.
Key points a strong answer covers
- Requirements first. Start from requirements and acceptance criteria; clarify gaps.
- Equivalence & boundaries. Equivalence partitioning and boundary value analysis.
- Negative cases. Negative and error cases.
- Security & non-functional. Security (lockout, injection), accessibility, browsers and devices.
- Prioritise by risk. Prioritise by risk.
Suggested answer structure
- Define it in one sentence.
- Explain how it works underneath.
- Give a practical example from code or a project.
- Close with a trade-off, pitfall or when you'd use it.
Common mistakes
- Only testing the happy path.
- Forgetting accessibility and security.
Likely follow-up questions
- What boundary values would you test for a password with 8–64 characters?
- How would you decide which cases to automate?
Example strong answer
I start from the acceptance criteria and ask about gaps: lockout rules, password rules, 'remember me', SSO. Then I design cases systematically. Positive: valid email and password logs in and lands on the right page. Negative: wrong password, unknown email, empty fields, invalid email format — with error messages that don't reveal which part was wrong. Boundaries: password length at 7, 8, 64 and 65 characters if the rule is 8–64. Security: lockout or rate limiting after repeated failures, input like SQL injection strings, passwords never logged or shown, session handling after logout. Non-functional: keyboard-only use, screen-reader labels, password managers, mobile and major browsers. Then I prioritise by risk and automate the stable, high-value ones.
3.
What makes a good bug report?
BeginnerTechnicalPractise this question and get feedbackWhat the interviewer is evaluating
Clear communication with developers.
Key points a strong answer covers
- Clear title. A specific, concise title.
- Steps to reproduce. Exact steps to reproduce.
- Expected vs actual. Expected vs actual result.
- Environment & evidence. Environment details plus screenshots, video and logs.
- Severity / priority. Severity, impact and frequency.
Suggested answer structure
- Define it in one sentence.
- Explain how it works underneath.
- Give a practical example from code or a project.
- Close with a trade-off, pitfall or when you'd use it.
Common mistakes
- Vague titles like 'login broken'.
- Missing environment or reproduction steps.
Likely follow-up questions
- What's the difference between severity and priority?
- What do you do if you can't reproduce a bug consistently?
Example strong answer
A good bug report lets a developer reproduce the problem without asking me anything. It has a specific title — 'Checkout total ignores discount code when cart has 10+ items' rather than 'checkout broken'. Then numbered steps to reproduce with the test data used, the expected result and the actual result, and the environment: build or version, browser or device, OS, user role. Evidence: a screenshot or short video, console errors, the failing network request, logs. I note how often it happens and assess severity — the technical impact — separately from priority, which the team decides. For intermittent bugs I record how often it occurs and any patterns I've found.
4.
What would you automate, and how do you keep a UI automation suite reliable?
IntermediateTechnicalPractise this question and get feedbackWhat the interviewer is evaluating
Sustainable test automation.
Key points a strong answer covers
- What to automate. Automate stable, repetitive, high-value regression and critical paths.
- Not everything. Leave exploratory, usability and fast-changing features manual.
- Stable selectors. Use stable selectors (roles, test ids), not brittle XPath.
- Waits & flakiness. Proper waits instead of sleeps; isolate test data; fix flaky tests.
- Tools & CI. Playwright/Cypress/Selenium in CI, page objects for structure.
Suggested answer structure
- Define it in one sentence.
- Explain how it works underneath.
- Give a practical example from code or a project.
- Close with a trade-off, pitfall or when you'd use it.
Common mistakes
- Using fixed sleeps.
- Tests depending on each other or on shared data.
Likely follow-up questions
- How do you handle a flaky test that fails 1 in 20 runs?
- When would you test through the API instead of the UI?
Example strong answer
I automate what's stable, repeated and valuable: regression of critical journeys like login, search and checkout, data-driven checks, and API tests — API tests are faster and more reliable than UI tests, so I push as much as possible there. Exploratory testing, usability and features still changing weekly stay manual. To keep UI tests reliable, I use Playwright or Cypress with stable locators — roles and dedicated test ids, not long XPath — and auto-waiting or explicit waits for conditions, never fixed sleeps. Each test creates its own data, often via the API, and doesn't depend on another test. Flaky tests are quarantined and fixed quickly, because a suite people don't trust gets ignored.
5.
How do you test a REST API?
IntermediateTechnicalPractise this question and get feedbackWhat the interviewer is evaluating
Whether you test APIs systematically, including security, not just the happy path.
Key points a strong answer covers
- Status codes & schema. Check status codes, response bodies and schemas.
- Positive & negative. Positive, negative and boundary inputs.
- Auth. Authentication and authorisation for each role.
- Tools. Postman/Newman, REST Assured, Playwright API testing.
- Non-functional. Performance, rate limits, idempotency and security.
Suggested answer structure
- Define it in one sentence.
- Explain how it works underneath.
- Give a practical example from code or a project.
- Close with a trade-off, pitfall or when you'd use it.
Common mistakes
- Only checking for 200 OK.
- Not testing authorisation between users.
Likely follow-up questions
- How would you test that user A can't read user B's data?
- What's contract testing?
Example strong answer
For each endpoint I check the happy path — correct status code, response body and that it matches the schema or contract — and the effect, like the record actually existing afterwards. Then negative cases: missing and invalid fields, wrong types, boundary values, unknown ids, and that errors return the right 4xx codes with useful messages. Security: requests with no token, an expired token, and a different user's token, to catch broken object-level authorisation — one of the most common API vulnerabilities. Also idempotency for retries, pagination and filtering. I automate these in Postman with Newman, REST Assured or Playwright's API testing in CI, and run load tests with k6 for key endpoints.
6.
How does QA fit into an agile team?
IntermediateTechnicalPractise this question and get feedbackWhat the interviewer is evaluating
Collaboration and shift-left mindset.
Key points a strong answer covers
- Involved early. Join refinement early — shift left.
- Acceptance criteria. Help write testable acceptance criteria.
- Testing within the sprint. Test continuously within the sprint, not at the end.
- Whole-team quality. Quality is a whole-team responsibility.
Suggested answer structure
- Define it in one sentence.
- Explain how it works underneath.
- Give a practical example from code or a project.
- Close with a trade-off, pitfall or when you'd use it.
Common mistakes
- Testing only after development finishes.
- Seeing QA as a gate rather than a partner.
Likely follow-up questions
- What is a 'three amigos' session?
- How would you handle a story that's not testable?
Example strong answer
In agile, QA isn't a phase at the end; it's part of the team from the start. In refinement I help shape stories into testable acceptance criteria with concrete examples, often in a three amigos session with a developer and the product owner, which catches misunderstandings before code is written. During the sprint I test continuously as pieces are ready, pair with developers on automation, and add tests to the pipeline so each story ships with its checks. Quality is a whole-team responsibility — developers write unit tests, I focus on risk, integration, exploratory testing and the automation strategy. I also bring data to retrospectives: escaped defects and flaky tests.
7.
How would you plan a performance test for a web application?
AdvancedTechnicalPractise this question and get feedbackWhat the interviewer is evaluating
Non-functional testing know-how.
Key points a strong answer covers
- Goals. Define goals: expected load and response-time targets.
- Test types. Load, stress, spike and soak tests.
- Realistic scenarios. Realistic journeys, data and think time, on a production-like environment.
- Tools. k6, JMeter, Gatling or Locust.
- Analyse. Analyse percentiles, errors and server metrics to find bottlenecks.
Suggested answer structure
- Define it in one sentence.
- Explain how it works underneath.
- Give a practical example from code or a project.
- Close with a trade-off, pitfall or when you'd use it.
Common mistakes
- Testing against a tiny environment and extrapolating.
- Reporting only averages.
Likely follow-up questions
- Why are percentiles better than averages?
- What's the difference between a stress and a soak test?
Example strong answer
First I'd agree on goals: the expected peak load — say 2,000 concurrent users at a sale — and targets like p95 response under 500 ms with under 1% errors. Then I model realistic journeys — browse, search, add to cart, check out — with their real proportions, think time and varied test data. I'd run a load test at the expected peak, a stress test beyond it to find the breaking point, a spike test for sudden surges, and a soak test for several hours to reveal memory leaks. Tools like k6 or JMeter, against a production-like environment. While it runs I watch server metrics — CPU, memory, database, queues — and report percentiles, throughput and errors, identifying the bottleneck rather than just the numbers.
8.
You find a serious bug the day before a release. What do you do?
IntermediateSituationalPractise this question and get feedbackWhat the interviewer is evaluating
Judgement and communication under pressure.
Key points a strong answer covers
- Confirm & assess impact. Reproduce it and assess impact and severity.
- Inform quickly. Tell the product owner, lead and developers immediately, with evidence.
- Options. Lay out options: fix and retest, disable behind a flag, delay, or release with a known issue.
- Decision isn't QA's alone. The business decides with the risk made clear.
- Follow up. Add a regression test and look at why it was found late.
Suggested answer structure
- Clarify the situation and what's at stake.
- Say what you'd do first, and why.
- Explain who you'd involve and how you'd communicate.
- Describe how you'd check the outcome and prevent a repeat.
Common mistakes
- Silently blocking the release yourself.
- Downplaying it to avoid conflict.
Likely follow-up questions
- What if the product owner wants to release anyway?
- How would you prevent late discoveries in future?
Example strong answer
First I'd make sure it's real and understand it: reproduce it, check how many users and which flows it affects, and whether there's a workaround. Then I'd raise it straight away — not wait for the stand-up — with the product owner, the lead and the developers, with clear steps and evidence. I'd lay out the options: fix it and retest the affected area, turn the feature off with a flag, delay the release, or release with a documented known issue if the impact is low. The decision is a business one, made together, but my job is to make the risk clear. Afterwards I'd add a regression test and raise in the retrospective why it was found so late.
Ready to answer them out loud?
Run a timed qa engineer mock interview, type or speak your answers, and get a score breakdown with what to improve.