Interview Questions

What test design techniques do you use to reduce test cases while keeping coverage high?

Explain the defect life cycle and the states a bug moves through.

A defect moves New → Assigned → Open/In Progress → Fixed → Retest → Verified → Closed, with Reopened and Deferred/Rejected as branch states.

How do you differentiate severity and priority when triaging a defect?

Severity measures technical impact on the system; priority measures business urgency to fix it. They're independent and can combine in any way.

How do you apply risk-based testing when you don't have time to test everything?

Rank features by probability of failure and business impact, then allocate testing effort and depth proportionally to that risk score.

What are entry and exit criteria in test planning, and why do teams skip them at their own risk?

Entry criteria define preconditions to start testing (stable build, environment ready, test cases reviewed); exit criteria define when testing is considered complete (coverage %, no open criticals).

What does 'shift-left' testing mean in practice, and how have you implemented it?

Shift-left means involving QA earlier in the SDLC — reviewing requirements and designs, writing tests alongside development, and catching defects before code is even written.

Explain the JavaScript event loop and how it affects asynchronous test code.

The event loop lets a single-threaded JS runtime handle async operations by pushing callbacks onto a queue that runs only after the call stack is empty, with microtasks (promises) draining before macrotasks (setTimeout).

Compare Promises with async/await — when would you choose one over the other in test automation?

Async/await is syntactic sugar over Promises that reads like synchronous code; Promises' .then chaining is still useful for running independent async operations in parallel with Promise.all.

What is a closure and where have you used one in a test automation framework?

A closure is a function that retains access to its enclosing scope's variables even after that outer function has returned, commonly used to create private state like counters or configured helper functions.

How does 'this' behave differently in regular functions vs arrow functions, and why does it matter in test hooks?

Regular functions get 'this' determined by how they're called (dynamic binding), while arrow functions inherit 'this' lexically from their enclosing scope at definition time.

Which array methods do you rely on most for shaping test data, and how do map/filter/reduce differ?

map transforms each element into a new array of the same length, filter keeps only elements matching a predicate, and reduce folds the array into a single accumulated value.

How do you properly handle and assert errors in asynchronous test code?

Wrap awaited calls in try/catch to assert on thrown errors, or use your test framework's rejection matcher like expect(promise).rejects.toThrow() instead of manually catching.

What's the difference between == and ===, and where has loose equality caused a subtle test bug?

== performs type coercion before comparing while === compares both type and value without coercion, so === is almost always the safer choice in assertions.

When would you use an interface versus a type alias in a test framework codebase?

Interfaces are best for object shapes that might be extended or merged (like page object or config contracts), while type aliases are more flexible for unions, tuples, and mapped types.

How do you use generics to build a reusable page object or API client class?

Generics let a single class or function work with multiple types safely, so an API client can return a strongly-typed response for whatever endpoint's shape you pass in.

Give examples of utility types you've used in an automation framework, like Partial, Pick, or Omit.

Partial<T> makes all fields optional for building partial test fixtures, Pick<T, K> extracts a subset of fields for a lightweight DTO, and Omit<T, K> removes fields you don't want exposed, like excluding a password from a response type.

What does strictNullChecks do, and why is it valuable in test automation code?

strictNullChecks makes null and undefined distinct types that must be explicitly handled, preventing runtime 'cannot read property of undefined' errors from locator/element lookups that silently return nothing.

When would you choose a union of string literals over an enum for something like environment names or test tags?

Union literal types are lighter-weight, don't emit any runtime JS, and work more naturally with plain string values from config files, whereas enums generate actual runtime objects and are better when you need reverse-mapping or namespacing.

How does declaration merging let you extend a test runner's fixture types, like adding custom Playwright fixtures?

Declaration merging lets you add new properties to an existing interface (like Playwright's TestArgs) by re-declaring it elsewhere with the same name, so TypeScript combines both declarations into one type.

How do you type an API client so response validation failures are caught at compile time, not just at runtime?

Define explicit interfaces for request/response payloads and pair them with a runtime schema validator like Zod, then infer the TypeScript type directly from that schema so compile-time types and runtime validation never drift apart.

Explain the difference between INNER JOIN, LEFT JOIN, and how you'd use them to validate test data relationships.

INNER JOIN returns only rows with matches in both tables, while LEFT JOIN returns all rows from the left table plus matched data from the right, with NULLs where no match exists — the latter is essential for finding orphaned records.

How do GROUP BY and HAVING differ, and when do you need HAVING instead of WHERE?

WHERE filters individual rows before grouping happens, while HAVING filters aggregated groups after GROUP BY has computed them, so you use HAVING when your condition depends on an aggregate like COUNT or SUM.

How would you use a window function to validate ordering or detect gaps in sequential test data?

Window functions like ROW_NUMBER(), RANK(), and LAG()/LEAD() let you compute values across a set of rows related to the current row without collapsing them into groups, which is ideal for detecting sequence gaps or comparing a row to the previous one.

How do indexes affect query performance, and what's a scenario where a missing index caused a test to time out?

An index creates a sorted lookup structure (typically a B-tree) so the database can find matching rows without scanning the entire table, turning an O(n) full table scan into a much faster O(log n) lookup.

When would you use a CTE instead of a subquery, and are there performance differences?

A CTE (WITH clause) improves readability by naming an intermediate result set you can reference multiple times, and recursive CTEs handle hierarchical data that a plain subquery cannot express at all, though most databases optimize non-recursive CTEs similarly to subqueries.

How do you verify database state after an API call in an automated test, and what pitfalls do you watch for?

Query the relevant table(s) directly after the API call using a unique identifier from the response, and guard against race conditions by polling with a timeout rather than asserting immediately, since some writes are asynchronous.

What's your approach to writing a query that finds duplicate records that shouldn't exist, and how do you decide which duplicate to keep when cleaning up?

Group by the fields that should be unique, filter with HAVING COUNT(*) > 1 to find duplicates, then use ROW_NUMBER() partitioned by those fields to identify which rows to keep (usually the earliest or most complete) versus delete.

Explain pytest fixtures and the difference between function, class, module, and session scope.

Fixtures are reusable setup/teardown functions injected into tests via dependency injection, and scope controls how often the fixture is created — function scope runs fresh per test, while session scope runs once for the entire test run.

How do you use the requests library to build API tests, including handling sessions and auth?

requests.Session() persists cookies, headers, and connection pooling across multiple calls, which is essential for API tests that need to authenticate once and reuse that auth state, rather than re-authenticating every request.

How do list and dict comprehensions improve readability when processing test data or API responses?

Comprehensions let you build a new list or dict from an iterable in a single readable expression, replacing multi-line for-loops with append/update calls, while also often running faster due to CPython optimizations.

Why do you use virtual environments, and how do you manage dependencies for a test automation project?

A virtualenv isolates a project's Python dependencies from the system's global packages, preventing version conflicts between projects and ensuring the exact library versions used in CI match what's on a developer's machine.

What are the key differences between unittest and pytest, and why might a team migrate from one to the other?

unittest is Python's built-in xUnit-style framework requiring class-based tests and self.assertX methods, while pytest allows plain functions with a simple assert statement, richer fixtures, and a much larger plugin ecosystem.

How do you use pytest.mark.parametrize to avoid duplicating near-identical test cases?

parametrize lets you run the same test function multiple times with different input/expected-output pairs supplied as a decorator, replacing several copy-pasted test functions with one data-driven test.

How would you structure a Page Object Model in Python for a Selenium/Playwright test suite?

Each page gets its own class encapsulating its locators and interaction methods (like login() or search()), so tests call high-level business actions instead of manipulating locators directly, isolating UI changes to one place.

How do you choose between ArrayList, LinkedList, HashMap and HashSet in test code?

ArrayList for ordered, index-accessed data, HashMap for key lookups such as test data by id, HashSet for uniqueness checks, LinkedList almost never in test frameworks.

How does HashMap work internally, and why must hashCode and equals agree?

HashMap stores entries in buckets chosen by hashCode; equals resolves collisions inside a bucket. If two equal objects return different hash codes they land in different buckets and lookups silently fail.

Interface vs abstract class — how does that decision show up in a test framework?

Abstract classes share state and common behaviour (BasePage, BaseTest); interfaces declare capability contracts (Reportable, DriverProvider) and allow multiple inheritance of type.

How do you use Java streams to prepare and verify test data?

Streams turn filter/map/collect chains into one readable line — building payload lists, extracting a column of a table, or asserting a property holds for every row.

How do you make WebDriver thread-safe for parallel execution?

Keep the driver in a ThreadLocal inside a DriverManager, create it in a @BeforeMethod and always remove() it in @AfterMethod to avoid leaking between threads.

How should exceptions be handled in an automation framework?

Never swallow exceptions in a try/catch that returns false — wrap them in a meaningful custom exception with context so the report shows why the step failed.