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.
Further reading
Authoritative sources
Related Tutorsbot tutorials
Share:
