300 Selenium Interview Questions & Answers (2026) — Crack Your Next SDET Round

Selenium is an open-source suite for automating web browsers. Its main component, Selenium WebDriver, is a W3C standard API implemented by every major browser. Freshers use it to write scripts in Java, Python, JavaScript, C#, or Ruby.

1. Selenium IDE — record-and-playback browser extension
2. Selenium WebDriver — code-first API (the main one)
3. Selenium Grid — distributed / parallel execution

The W3C-standard programming interface for controlling a browser. Each browser ships its own driver (ChromeDriver, GeckoDriver, EdgeDriver) that translates WebDriver commands into browser-native actions.

<dependency>
  <groupId>org.seleniumhq.selenium</groupId>
  <artifactId>selenium-java</artifactId>
  <version>4.28.0</version>
</dependency>

WebDriver driver = new ChromeDriver();
driver.get("https://example.com");
driver.quit();

No — Selenium 4.6+ ships Selenium Manager, which auto-downloads the right driver. You just do new ChromeDriver().

close() closes the current tab. quit() closes all tabs and ends the WebDriver session. Always quit() in @AfterMethod to avoid leaked browser processes.

• id, name, className, tagName
• linkText, partialLinkText
• cssSelector, xpath
• Selenium 4 relative locators: above/below/toLeftOf/toRightOf/near

Prefer CSS: shorter, faster, cleaner. Use XPath when you need text(), parent axis, or starts-with. Never chain 6 levels of XPath — use test IDs instead.

driver.findElement(By.cssSelector("[data-test='submit']")).click();

findElement returns the first match or throws NoSuchElementException. findElements returns a (possibly empty) list — great for checking absence: list.isEmpty().

WebElement email = driver.findElement(By.id("email"));
email.clear();
email.sendKeys("qa@example.com");

element.getText();                 // visible innerText
element.getAttribute("value");    // form input value
element.getDomProperty("value");  // Selenium 4 — live DOM property

Prefer explicit. Implicit sets a global polling timeout on every findElement; it's blunt and can mask real bugs. Explicit waits target one condition:

new WebDriverWait(driver, Duration.ofSeconds(10))
  .until(ExpectedConditions.elementToBeClickable(By.id("submit")));

Wait<WebDriver> w = new FluentWait<>(driver)
  .withTimeout(Duration.ofSeconds(15))
  .pollingEvery(Duration.ofMillis(500))
  .ignoring(StaleElementReferenceException.class);
w.until(d -> d.findElement(By.id("row-42")));

Only in test authoring/debugging. In real scripts it's an anti-pattern — replace with explicit waits or the correct ExpectedConditions.

Re-find the element after the DOM change, or wrap the action in a wait+retry (FluentWait ignoring the exception). Cache locators, not WebElements.

wait.until(ExpectedConditions.urlContains("/dashboard"));
wait.until(ExpectedConditions.titleIs("Dashboard"));

Alert a = driver.switchTo().alert();
a.getText();
a.accept();  // or a.dismiss();

driver.switchTo().frame("frame-name");
// ... interact ...
driver.switchTo().defaultContent();

String parent = driver.getWindowHandle();
for (String h : driver.getWindowHandles()) {
  if (!h.equals(parent)) driver.switchTo().window(h);
}

new Actions(driver)
  .moveToElement(menu)
  .clickAndHold(item)
  .moveToElement(target)
  .release()
  .perform();

JavascriptExecutor js = (JavascriptExecutor) driver;
js.executeScript("arguments[0].scrollIntoView(true);", element);
js.executeScript("arguments[0].click();", element);

Use sparingly — it bypasses real user behavior.

TestNG is the runner that gives Selenium tests: annotations (@Test, @BeforeMethod), data-driven support (@DataProvider), parallel execution via testng.xml, listeners, and reports. See our TestNG Q&A.

A design pattern where each page is a class with locators as fields and user actions as methods. Keeps tests readable and locators in one place — the #1 pattern freshers must know.

public class LoginPage {
  private final WebDriver d;
  private final By email = By.id("email");
  private final By pwd   = By.id("password");
  private final By submit = By.id("login");
  public LoginPage(WebDriver d) { this.d = d; }
  public void loginAs(String e, String p) {
    d.findElement(email).sendKeys(e);
    d.findElement(pwd).sendKeys(p);
    d.findElement(submit).click();
  }
}

ChromeOptions opts = new ChromeOptions();
opts.addArguments("--headless=new", "--window-size=1280,900");
WebDriver driver = new ChromeDriver(opts);

• W3C-only protocol
• Relative locators (above/below/near)
• Selenium Manager (auto driver download)
• Chrome DevTools Protocol (CDP) access
• Better Grid architecture

India: ₹3.5–6 LPA. US: $60–80k. UK: £28–38k. See our Selenium tester salary guide and full QA salary guide. Rehearse with our AI Mock Interview, then go deeper with the 300-Q hub.

driver.close() closes only the current active browser tab or window where WebDriver currently has focus, leaving the underlying browser driver session active if other windows remain open. In contrast, driver.quit() closes every open browser window, terminates the native browser process, and completely destroys the WebDriver session on the OS. Forgetting to call driver.quit() in teardown hooks causes zombie chromedriver processes to accumulate on CI/CD runner nodes, exhausting server memory.

driver.quit(); // Closes all windows and terminates session safely

findElement() immediately throws a NoSuchElementException if the element is not present in the DOM when polling concludes. Conversely, findElements() never throws NoSuchElementException when matches are absent; instead, it returns an empty Java List<WebElement> with size zero. Experienced engineers leverage findElements().isEmpty() to verify absence of elements without writing try-catch blocks around findElement().

List<WebElement> list = driver.findElements(By.id("optional"));
boolean isAbsent = list.isEmpty();

Implicit wait sets a global DOM polling duration for element presence across all findElement calls. Explicit wait (WebDriverWait) pauses execution until a specific ExpectedCondition (such as visibility or clickability) evaluates to true for a particular element. FluentWait is the parent implementation of WebDriverWait that allows custom configuration of polling frequency and specific exception ignoring (e.g., ignoring ElementClickInterceptedException while waiting).

Wait<WebDriver> wait = new FluentWait<>(driver)
    .withTimeout(Duration.ofSeconds(20))
    .pollingEvery(Duration.ofMillis(500))
    .ignoring(NoSuchElementException.class);

When implicit and explicit waits are mixed, browser drivers experience timeout collision. If an implicit wait of 10 seconds is set globally alongside an explicit wait of 15 seconds, the driver may poll the implicit wait full duration on every internal lookup triggered by the explicit wait condition. This can cause a simple 15-second explicit wait to block thread execution for over 150 seconds under failure conditions.

// NEVER mix: driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));
// Standardize on explicit waits exclusively:
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(15));

When automating standard DOM <select> elements, Selenium provides the org.openqa.selenium.support.ui.Select wrapper class. Engineers pass the located WebElement into the Select constructor and invoke selectByVisibleText(), selectByValue(), or selectByIndex(). Attempting to click standard <option> tags directly without the Select wrapper often throws ElementNotInteractableException on headless browsers.

Select countryDropdown = new Select(driver.findElement(By.id("country")));
countryDropdown.selectByVisibleText("United States");

Modern UI frameworks build dropdowns using <div>, <ul>, and <li> tags styled with CSS. Attempting to instantiate a Select class on a non-<select> tag throws UnexpectedTagNameException. To automate custom dropdowns, click the trigger element to expand the list, query driver.findElements() for the option list items, and iterate through them to match visible text before clicking.

driver.findElement(By.id("custom-dropdown-trigger")).click();
for (WebElement opt : driver.findElements(By.cssSelector(".dropdown-item"))) {
    if (opt.getText().trim().equals("Enterprise Tier")) { opt.click(); break; }
}

JavaScript alerts exist outside the HTML DOM; standard locators cannot find alert buttons. To handle alerts, engineers must pause execution until ExpectedConditions.alertIsPresent() resolves, then invoke driver.switchTo().alert(). Once switched, call alert.accept() to click OK, alert.dismiss() to click Cancel, or alert.sendKeys() to input text into prompt dialogues.

Alert alert = wait.until(ExpectedConditions.alertIsPresent());
System.out.println("Alert text: " + alert.getText());
alert.accept();

Iframes encapsulate independent HTML documents inside parent frames. Elements inside an iframe throw NoSuchElementException if queried from the parent context. Switch context using driver.switchTo().frame(index | name | WebElement). Once iframe actions conclude, invoke driver.switchTo().defaultContent() to revert focus back to the top-level document structure.

wait.until(ExpectedConditions.frameToBeAvailableAndSwitchToIt(By.id("payment-frame")));
driver.findElement(By.id("cvv")).sendKeys("123");
driver.switchTo().defaultContent();

Use driver.getWindowHandle() before clicking to record the parent window string ID. After clicking, invoke driver.getWindowHandles() to obtain a Set<String> containing all open window IDs. Iterate through the set and call driver.switchTo().window(handle) when the handle does not match the parent ID.

String parent = driver.getWindowHandle();
driver.findElement(By.id("oauth-login")).click();
for (String h : driver.getWindowHandles()) {
    if (!h.equals(parent)) { driver.switchTo().window(h); break; }
}

When sticky navigation bars or modal backdrops obscure target buttons, native driver.click() throws ElementClickInterceptedException. Casting WebDriver to JavascriptExecutor allows injecting direct DOM click instructions (`arguments[0].click()`), bypassing viewport coordinate occlusion entirely.

JavascriptExecutor js = (JavascriptExecutor) driver;
WebElement hiddenBtn = driver.findElement(By.id("submit"));
js.executeScript("arguments[0].click();", hiddenBtn);

Elements outside the viewport may throw ElementNotInteractableException on Safari or older ChromeDriver versions. Use JavascriptExecutor with `arguments[0].scrollIntoView(true);` to align the top of the element with the top of the viewport prior to interaction.

WebElement footerLink = driver.findElement(By.id("terms"));
((JavascriptExecutor) driver).executeScript("arguments[0].scrollIntoView(true);", footerLink);
footerLink.click();

Multi-level navigation menus require hovering over parent items before child links render in the DOM. Instantiate org.openqa.selenium.interactions.Actions, chain moveToElement(target), and append .perform() to execute the built composite action chain.

Actions actions = new Actions(driver);
WebElement menu = driver.findElement(By.id("products-menu"));
actions.moveToElement(menu).perform();
wait.until(ExpectedConditions.elementToBeClickable(By.id("cloud-tier"))).click();

Drag-and-drop Kanban boards require clicking and holding a source card, dragging to target coordinates, and releasing the mouse button. The Actions class provides dragAndDrop(source, target).perform() to orchestrate these low-level OS pointer events.

WebElement sourceCard = driver.findElement(By.id("task-101"));
WebElement targetColumn = driver.findElement(By.id("done-col"));
new Actions(driver).dragAndDrop(sourceCard, targetColumn).perform();

Automated pipelines require visual artifacts when assertions fail. Implement TestNG ITestListener, override onTestFailure(ITestResult), cast the active WebDriver instance to TakesScreenshot, and save the OutputType.FILE artifact to the target artifact directory.

File src = ((TakesScreenshot) driver).getScreenshotAs(OutputType.FILE);
Files.copy(src.toPath(), new File("target/screenshots/fail.png").toPath());

Absolute XPaths break whenever page layout shifts. To locate dynamic action buttons inside tables, query for the stable row identifier (`//td[text()='User101']`) and navigate across DOM siblings using `/following-sibling::td//button[@class='delete']`.

WebElement delBtn = driver.findElement(By.xpath("//td[text()='user@test.com']/following-sibling::td//button[@title='Delete']"));
delBtn.click();

getText() returns the inner text rendered between HTML opening and closing tags (`<label>Inner Text</label>`). For form input fields (`<input type='text'>`), typed text is stored in the DOM `value` attribute, which returns empty string if queried via getText(). Use getAttribute("value") to read input field contents.

String inputContent = driver.findElement(By.id("username")).getAttribute("value");
Assert.assertEquals(inputContent, "expected_user");

isDisplayed() verifies visual rendering on the page viewport; isEnabled() checks if form inputs accept user interaction (not disabled); isSelected() verifies whether radio buttons or checkboxes are currently checked.

WebElement checkbox = driver.findElement(By.id("agree"));
if (!checkbox.isSelected()) { checkbox.click(); }
Assert.assertTrue(checkbox.isSelected());

OS file picker dialogs cannot be automated directly by Selenium WebDriver. If the HTML structure contains an `<input type='file'>` element, invoke sendKeys("/absolute/path/to/file.pdf") directly onto the file input element to bypass OS dialogs.

WebElement fileInput = driver.findElement(By.cssSelector("input[type='file']"));
fileInput.sendKeys(new File("src/test/resources/sample.pdf").getAbsolutePath());

To verify all page links without clicking them sequentially, extract all `<a>` tags via findElements(By.tagName("a")), iterate through their `href` attributes, open HttpURLConnection instances, and assert that HTTP response status codes are less than 400.

URL url = new URL(linkElement.getAttribute("href"));
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.connect();
Assert.assertTrue(conn.getResponseCode() < 400, "Broken link detected");

Running automated suites inside Linux CI containers requires headless rendering without a graphical X11 server. Instantiate ChromeOptions and pass arguments `--headless=new`, `--disable-gpu`, and `--window-size=1920,1080`.

ChromeOptions options = new ChromeOptions();
options.addArguments("--headless=new", "--window-size=1920,1080");
WebDriver driver = new ChromeDriver(options);

Page Object Model creates an object-oriented class for each web application screen, encapsulating locators and operational workflows as class methods. Tests interact strictly with page methods (`loginPage.login(u, p)`), ensuring UI locator refactoring is confined to a single page class rather than updating hundreds of test scripts.

public class LoginPage {
    private By email = By.id("user");
    public void login(String u) { driver.findElement(email).sendKeys(u); }
}

PageFactory is an extension of POM that initializes WebElements declaratively using `@FindBy(id = "login") WebElement loginBtn`. Calling `PageFactory.initElements(driver, this)` proxies element lookups until the exact moment the element method is executed.

@FindBy(id = "submit") private WebElement submitBtn;
public LoginPage(WebDriver d) { PageFactory.initElements(d, this); }

Standard TestNG `Assert.assertEquals()` executes a hard assertion that immediately throws AssertionError and aborts remaining test method execution upon failure. `SoftAssert` accumulates all assertion failures across multiple steps without aborting execution, reporting all collected failures only when `softAssert.assertAll()` is invoked at method teardown.

SoftAssert soft = new SoftAssert();
soft.assertEquals(pageTitle, "Home");
soft.assertTrue(userBadge.isDisplayed());
soft.assertAll(); // Mandate reporting at end

In `testng.xml`, set attribute `parallel="methods"` or `parallel="classes"` along with `thread-count="4"` inside the `<suite>` tag. Each parallel worker thread instantiates an independent execution workflow.

<suite name="ParallelSuite" parallel="methods" thread-count="4">
    <test name="Regression"><classes><class name="com.tests.LoginTest"/></classes></test>
</suite>

When multiple TestNG threads run concurrently, sharing a static WebDriver instance causes thread interference where Thread A navigates away while Thread B is executing assertions. Wrapping WebDriver inside `ThreadLocal<WebDriver>` creates isolated driver instances per execution thread.

private static ThreadLocal<WebDriver> tlDriver = new ThreadLocal<>();
public static void setDriver(WebDriver d) { tlDriver.set(d); }
public static WebDriver getDriver() { return tlDriver.get(); }

Selenium 4 exposes bi-directional Chrome DevTools Protocol WebSocket connections. Engineers create a DevTools session, enable the Network domain, and add listeners to intercept request URLs and return synthetic HTTP status codes or JSON bodies.

DevTools devTools = ((ChromeDriver) driver).getDevTools();
devTools.createSession();
devTools.send(Network.enable(Optional.empty(), Optional.empty(), Optional.empty()));

Using Selenium 4 CDP commands, engineers pass `Emulation.setGeolocationOverride()` to simulate regional GPS coordinates and `Network.emulateNetworkConditions()` to simulate cellular throttling.

devTools.send(Emulation.setGeolocationOverride(Optional.of(18.5204), Optional.of(73.8567), Optional.of(100.0)));

Selenium 4 Relative Locators locate elements based on visual DOM proximity (`above()`, `below()`, `toLeftOf()`, `near()`). For instance, finding an input box directly `below` a label simplifies XPath syntax.

WebElement input = driver.findElement(with(By.tagName("input")).below(driver.findElement(By.id("label"))));

Selenium Grid 4 decomposes monolithic hubs into Router, Session Queue, Distributor, and Node containers. Deploying official `selenium/router` and `selenium/node-chrome` images enables horizontal scale.

services:
  router: { image: selenium/router:4.18.1, ports: ["4444:4444"] }
  chrome: { image: selenium/node-chrome:4.18.1, shm_size: 2gb }

Linux containers default to a 64MB `/dev/shm` shared memory filesystem. Chromium utilizes `/dev/shm` to render pages; when memory exceeds 64MB, Chrome crashes. Pass `--disable-dev-shm-usage` to force disk buffering.

options.addArguments("--disable-dev-shm-usage"); // Critical for Docker stability

Implement `IRetryAnalyzer` interface and override `retry(ITestResult)`. Increment a counter up to `MAX_RETRY` to re-execute intermittent network failures automatically before marking builds failed.

public boolean retry(ITestResult result) { if (count < 2) { count++; return true; } return false; }

Annotate a data supplier method with `@DataProvider(name = "data")` returning `Object[][]`. Reference this provider inside `@Test(dataProvider = "data")` to execute parameterized test iterations.

@DataProvider(name = "logins") public Object[][] data() { return new Object[][] { {"admin", "pass"} }; }

`StaleElementReferenceException` occurs when a located WebElement is detached from the DOM due to asynchronous JavaScript re-rendering. `ElementNotInteractableException` occurs when an element exists in the DOM but cannot receive events because it is hidden or disabled.

// Fix StaleElement: re-query element inside wait.until loop before interaction

Pass `setAcceptInsecureCerts(true)` on `ChromeOptions` or `FirefoxOptions` to bypass browser HTTPS warning interstitials automatically during QA staging tests.

ChromeOptions options = new ChromeOptions();
options.setAcceptInsecureCerts(true);

Enable `Log.enable()` via CDP DevTools session or query `driver.manage().logs().get(LogType.BROWSER)` to assert that zero JavaScript SEVERE errors occurred during E2E navigation.

LogEntries logs = driver.manage().logs().get(LogType.BROWSER);
for (LogEntry l : logs) { Assert.assertNotEquals(l.getLevel().toString(), "SEVERE"); }

Create a custom `findElementWithFallback()` method that attempts a primary locator and catches `NoSuchElementException` to fall back to backup locators (`data-testid` or CSS) while logging self-healing alerts.

try { return driver.findElement(primary); } catch (NoSuchElementException e) { return driver.findElement(backup); }

Selenium 4 embeds native OpenTelemetry tracing hooks. Setting system properties for OTLP endpoints exports command latency spans directly to Datadog or Jaeger dashboards.

System.setProperty("otel.traces.exporter", "otlp");

Use `Actions.doubleClick(element).perform()` and `Actions.contextClick(element).perform()` to dispatch specialized mouse OS pointer events.

new Actions(driver).doubleClick(item).perform();

`pom.xml` manages library dependencies (Selenium, TestNG, ExtentReports) and configures `maven-surefire-plugin` to execute specific suite XML files across environment profiles (`-Pstaging`).

<plugin><artifactId>maven-surefire-plugin</artifactId><configuration><suiteXmlFiles><file>testng.xml</file></suiteXmlFiles></configuration></plugin>

Selenium Manager is a built-in CLI tool written in Rust that detects system browser versions and automatically downloads matching driver binaries (`chromedriver`, `geckodriver`) without requiring `System.setProperty()` paths.

WebDriver driver = new ChromeDriver(); // Zero setup required due to Selenium Manager

Listeners intercept framework lifecycle events. Implementing `ISuiteListener` executes global database seeding before any test runs; `IInvokedMethodListener` audits test execution duration.

public class SuiteListener implements ISuiteListener { public void onStart(ISuite suite) { /* Global setup */ } }

Shadow DOM encapsulates internal styling. Call `element.getShadowRoot()` on the shadow host WebElement to obtain a `SearchContext` handle, then locate internal shadow elements using CSS selectors.

SearchContext shadow = driver.findElement(By.id("shadow-host")).getShadowRoot();
shadow.findElement(By.cssSelector("input#shadow-input")).sendKeys("data");

`executeAsyncScript()` injects a callback function into the browser script arguments. The Java driver blocks thread execution until the client JavaScript explicitly invokes the callback.

long start = System.currentTimeMillis();
((JavascriptExecutor) driver).executeAsyncScript("var callback = arguments[arguments.length - 1]; setTimeout(callback, 2000);");

Extract cookies using `driver.manage().getCookies()`. After launching a clean incognito window and navigating to the application domain, inject saved cookies via `driver.manage().addCookie(cookie)` to restore authentication.

Cookie token = new Cookie("SESSIONID", "jwt_value");
driver.manage().addCookie(token);

JSON Wire Protocol required driver intermediaries to encode/decode commands over HTTP, causing latency. W3C WebDriver specification is standardized natively inside Chromium and WebKit rendering engines, eliminating encoding translation overhead.

// Standardized W3C execution guarantees uniform behavior across Chrome, Safari, and Firefox

Iterate through table header cells (`//table//th`) to dynamically map column titles (`Email`, `Status`) to integer index positions before querying data rows.

int colIdx = 1;
for (WebElement th : driver.findElements(By.xpath("//table//th"))) { if (th.getText().equals("Status")) break; colIdx++; }