Software testing interviews combine fundamentals, tool-specific questions, and scenario-based problem solving. This guide covers the 40 most frequently asked questions across manual testing, automation, STLC, and ISTQB fundamentals — with structured answers you can adapt to your own voice.
Fundamentals (Q1–Q10)
- What is the difference between verification and validation? Verification = are we building the product right? (reviews, walkthroughs, inspections). Validation = are we building the right product? (actual execution against requirements).
- What is the software testing life cycle (STLC)? Requirements → Test Planning → Test Case Design → Environment Setup → Execution → Closure.
- What is the test pyramid? Unit tests (many, fast) → integration tests (fewer) → E2E tests (fewest, slow). Inverting it produces slow + flaky suites.
- What is boundary value analysis? Test on, just below, and just above the boundary. Catches off-by-one bugs.
- What is equivalence partitioning? Group inputs that should behave the same; test one from each group. Reduces test count without losing coverage.
- What is a test case? ID, description, preconditions, steps, expected, actual, status, severity, priority.
- What is the difference between severity and priority? Severity = technical impact. Priority = business urgency.
- What is a regression test? Re-running existing tests after a change to catch unintended impact.
- What is a smoke test? Quick check that the critical paths work — gates further testing.
- What is a sanity test? Narrow regression after a small change.
Test Design & Techniques (Q11–Q20)
- Decision tables — combinations of conditions → actions. Powerful for business rules.
- State transition testing — model states + valid transitions; invalid transitions = bugs.
- Pairwise testing — cover all 2-way combinations of parameter values.
- Exploratory testing — simultaneous learning + test design + execution. Charters + time-boxed sessions.
- Mutation testing — inject small changes, verify tests catch them. Higher signal than line coverage.
- Property-based testing — generate random inputs, verify invariants. Hypothesis, fast-check, jqwik.
- Risk-based testing — prioritise by probability × impact. High-risk areas get thorough coverage.
- Traceability matrix — requirements → test cases → defects. Proves coverage.
- Test estimation — function-point, use-case-point, or expert judgment. Never a single number.
- Test metrics — defect density, MTTR, test coverage, escape rate. Few, not many.
Automation & Modern Testing (Q21–Q30)
- Selenium vs Playwright vs Cypress — Selenium is broad; Playwright is fast + auto-waiting; Cypress is dev-friendly but limited to Chromium/Firefox/WebKit.
- Page Object Model — one class per page, holds locators + actions. Tests interact with page objects, not selectors.
- Why explicit waits beat hardcoded sleeps — explicit waits are condition-driven and stable; sleeps are timing magic.
- API testing basics — REST/JSON, status codes, auth (Bearer/OAuth), contract tests, mocking external deps.
- Performance testing types — load, stress, soak, spike. Different questions, different tests.
- Test data management — fixtures + factories + per-test isolation. Tests must not share state.
- CI/CD integration — every commit runs lint + unit + integration tests. PR merge gated on green.
- Flaky tests — investigate immediately. Most are timing-related or have hidden dependencies.
- Visual regression — screenshot comparison. Catches unintended UI changes.
- Contract testing — Pact / Spectator. Catch breaking API changes between teams.
Scenarios & Problem Solving (Q31–Q40)
- How would you test a login form? — happy path, wrong credentials, empty fields, SQL injection, XSS, brute force lockout, MFA, accessibility, mobile, performance.
- How would you test an API? — happy path, error codes, auth failures, payload validation, rate limits, pagination, contract, security.
- Bug report template — title, steps to reproduce, expected, actual, environment, screenshots, logs, severity.
- How would you prioritise 100 bugs with limited time? — severity × impact × customer reach. Fix the top 5%, defer the rest with documented justification.
- How would you test without requirements? — exploratory testing, charters, reference competitors, define acceptance criteria with stakeholders.
- What would you automate first? — high-traffic critical paths that run frequently and rarely change.
- What would you NOT automate? — one-off exploratory work, UI features that change weekly, tests that only humans can evaluate.
- How do you test a feature behind a feature flag? — test both flag states (on + off); automate; coordinate with product on rollout.
- How do you handle a bug you cannot reproduce? — collect more data (logs, environment, repro steps), pair with dev, narrow the surface, escalate if customer impact is high.
- How do you measure test effectiveness? — defect escape rate, MTTR, % of bugs caught in dev vs prod, coverage of critical paths.
Interview format and what hiring managers actually evaluate
Most software-testing interviews in 2026 follow a four-stage format. Stage one is a 30-minute phone screen focused on fundamentals — STLC, test pyramid, severity versus priority, and one or two scenario questions. Stage two is a 60-minute technical round where the interviewer walks through a real bug or asks you to design test cases for a feature like a search bar or a payment flow. Stage three is a take-home or live coding exercise (writing automation in Python or Java). Stage four is a culture-and-team fit conversation.
- What they test — fundamentals depth, structured thinking, communication, automation literacy, risk prioritisation.
- Red flags — vague answers, no concrete examples, inability to explain trade-offs between manual and automated testing.
- How to stand out — bring a portfolio (GitHub repo with a test framework you built, a bug report template you designed, a metrics dashboard you shipped).
Resources for continued preparation
These 40 questions are the foundation. To deepen your preparation further, work through the ISTQB Foundation Level syllabus, build at least one Playwright or Cypress project end-to-end, and practice writing bug reports on open-source projects (file real issues on GitHub to build your portfolio).
- Certifications — ISTQB CTFL, ISTQB CTAL (advanced level), or a tool-specific cert from Selenium, Playwright, or Cypress.
- Books — Lessons Learned in Software Testing (Kaner, Bach, Pettichord), Exploratory Software Testing (Hendrickson), The Agile Testing Collection.
- Communities — Ministry of Testing, Software Testing Club, r/QualityAssurance on Reddit, Test Tribe Slack.
Share:
