Question 1
Difficulty: medium
How do you decide which test cases to automate versus keep manual in a project?
Sample answer
I decide based on repetition, risk, stability, and return on effort. If a test is executed often, covers a critical business flow, and the application behavior is relatively stable, I usually push it toward automation. Good examples are smoke tests, regression suites, and core API checks. I keep exploratory testing, usability checks, and features that change frequently as manual because automation there can become expensive to maintain and less valuable. I also consider the skill set of the team and the test environment. If data setup is complex or the UI is volatile, I may automate at the API or service layer instead of the UI. My goal is not to automate everything, but to create a balanced suite that gives fast feedback and protects high-risk areas without creating unnecessary maintenance overhead.
Question 2
Difficulty: medium
Describe a time when you found a serious defect late in the testing cycle. How did you handle it?
Sample answer
In one project, I found a critical payment issue during final regression, just before release. The defect only appeared under a specific combination of discount code, tax rule, and browser session timeout, so it had escaped earlier checks. I documented the issue clearly, including exact repro steps, screenshots, logs, and the business impact. Then I quickly aligned with the developer, product owner, and QA lead on severity and release risk. Since the defect affected transactions, we paused the release and focused on isolating the root cause. I also helped define a targeted retest plan so we could verify the fix and confirm no related flows were broken. The experience reinforced the importance of covering edge cases earlier and keeping traceability strong. I now pay close attention to boundary conditions and high-risk combinations during test planning.
Question 3
Difficulty: easy
What is your approach to creating a test plan for a new feature?
Sample answer
I start by understanding the feature in business terms, not just technical terms. I want to know the user flow, the acceptance criteria, dependencies, and what could fail in production. From there, I identify test scope, risks, environments, and the type of testing needed, including functional, regression, integration, and negative cases. I also look for data requirements, external systems, and any assumptions that might affect results. For prioritization, I focus first on the highest-value and highest-risk scenarios, then add edge cases and non-functional checks where relevant. I make sure the plan is practical, meaning it fits the timeline and is easy for the team to execute and maintain. A good test plan should help the team make decisions, not just create documentation. I keep it lightweight enough to stay useful, but detailed enough to support repeatable testing and clear coverage.
Question 4
Difficulty: easy
How do you handle disagreements with a developer about whether something is a bug?
Sample answer
I try to keep the conversation objective and tied to requirements, behavior, and user impact. If there is disagreement, I first confirm the expected outcome from the spec, acceptance criteria, or product owner if needed. Then I reproduce the issue carefully and share evidence such as logs, screenshots, and the exact environment. I avoid framing it as a personal debate. Instead, I ask questions like, “What behavior was intended here?” or “What would the user experience be in this case?” That usually helps shift the focus to the product rather than the opinion. If it still isn’t clear, I escalate in a respectful way and ask for a quick decision from the right stakeholder. I have found that strong collaboration works better than trying to “win” the argument. The goal is to protect quality and ship the right behavior, not prove someone wrong.
Question 5
Difficulty: medium
Which types of defects have you found most often, and how do you prevent them from recurring?
Sample answer
The defects I see most often are validation issues, boundary-condition failures, data handling problems, and environment-related issues. For example, fields that accept invalid input, workflows that break when a record is unusually large, or failures caused by missing test data or a mismatched configuration. To prevent recurrence, I look at patterns rather than individual bugs. If I see the same kind of issue repeatedly, I update the test checklist, add regression coverage, and raise it in the team’s retrospective. I also like to work closely with developers early so we can catch weak points during design or code review rather than after implementation. When appropriate, I suggest unit or API-level checks that can catch the issue sooner. Over time, this reduces repeated defects and improves the overall quality of the release process. I see prevention as part of the test engineer’s job, not just defect reporting.
Question 6
Difficulty: hard
How do you test an application when requirements are incomplete or changing quickly?
Sample answer
When requirements are moving, I focus on risk-based testing and fast feedback. I start by identifying the core user goal and the parts of the workflow that are least likely to change, then I test those first. I ask clarifying questions early and document assumptions so there is a shared understanding of what is being validated. If the requirements are incomplete, I use exploratory testing to uncover gaps and edge cases while keeping notes on what I observed. I also prefer to test at smaller levels, such as APIs or isolated modules, because they are often easier to validate while the UI or business rules are still shifting. Communication is important here. I keep the product owner and developers updated on what I am testing and where I see ambiguity. That helps the team make decisions quickly and reduces the chance of rework later in the cycle.
Question 7
Difficulty: hard
What steps do you take when a test fails intermittently?
Sample answer
Intermittent failures can be tricky, so I approach them systematically. First, I confirm whether the failure is truly inconsistent by rerunning the test under the same conditions and checking related logs, screenshots, and timestamps. Then I look for patterns: timing issues, data dependencies, environment instability, race conditions, or test isolation problems. I also compare the failing run with a passing run to see what changed. If the test is automated, I review the script for brittle locators, hard-coded waits, or shared state between tests. If the issue appears to be in the product, I gather evidence from multiple runs so the development team can reproduce it. I never treat a flaky failure lightly, because it can hide real defects and damage trust in the test suite. My goal is to determine whether the problem is in the product, the test, or the environment, and then fix the root cause rather than just rerunning until it passes.
Question 8
Difficulty: medium
How do you ensure good test coverage without making the suite too slow to run?
Sample answer
I keep coverage focused on business risk and execution speed. The first step is to define a clear test pyramid, with more checks at the unit and API level and fewer end-to-end UI tests. That helps cover logic early while keeping the full suite manageable. I separate smoke, critical path, and regression tests so the team can run the smallest useful set for each stage of delivery. I also look for duplication and remove overlapping cases that do not add new value. Another important factor is test data and environment setup. If those are slow, I try to simplify them or use service-level stubs where appropriate. For automation, I write tests to be independent and parallel-friendly, which improves runtime. I see speed as part of quality because a slow suite gets ignored. Good coverage only matters if the team can actually use it every day.
Question 9
Difficulty: medium
Tell me about a time you improved a testing process or workflow.
Sample answer
In a previous role, the team was spending too much time manually retesting the same core flows after every build. I reviewed the release pattern and noticed that a small set of scenarios caused most of the release risk. I worked with the team to define a focused smoke suite and automated the most stable, high-value checks at the API level first. I also organized the test cases by feature and severity so we could quickly identify what mattered most when something failed. As a result, we reduced repetitive manual effort and got faster release feedback. More importantly, the team became more confident about which tests needed attention and which could be run automatically. I think process improvement should always be practical. It should save time, improve visibility, and make it easier for developers and testers to work together without adding unnecessary complexity.
Question 10
Difficulty: easy
How do you validate that a defect fix is complete and did not introduce side effects?
Sample answer
I start by retesting the exact defect scenario using the same data and environment where the issue was originally seen. Once I confirm the fix, I test the surrounding flows to make sure the change did not break related behavior. I like to think in terms of impact radius: what functions, integrations, or edge cases could be affected by this change? If the fix touches shared code, I broaden my checks to include regression around those areas. I also review any commit notes or release details to understand what changed technically. When possible, I use both positive and negative scenarios so I’m not just confirming the happy path. If automation exists for that area, I add or update cases to protect against regression in future builds. A fix is only truly complete when the original problem is solved and the surrounding experience still behaves as expected.
