Most Asked Selenium Interview Questions and Answers: Top 80 [2025]

Its key advantage is that it enables testing of modern web applications without the need for manual interaction.

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

• Selenium IDE: A browser plugin used for record-and-playback testing.
• Selenium WebDriver: The core API that allows you to write test scripts.
• Selenium Grid: Supports distributed test execution across multiple machines and browsers.
• Selenium RC (Deprecated): An older tool that has now been replaced by WebDriver.

• It only supports web-based applications, not desktop or mobile apps (unless used with Appium).
• No built-in reporting mechanism — external tools are needed.
• Handling CAPTCHAs or barcode scanners requires workarounds.
• Steep learning curve for advanced automation.

Think of Selenium 3.0 as a cleaner, more modern WebDriver-centric framework.

• ID
• Name
• Class Name
• Tag Name
• Link Text & Partial Link Text
• XPath
• CSS Selector

Choosing the right locator improves script stability and execution speed.

// Returns one WebElement
WebElement button = driver.findElement(By.id("submit"));

// Returns a list
List links = driver.findElements(By.tagName("a"));

System.setProperty("webdriver.chrome.driver", "path/to/chromedriver");
WebDriver driver = new ChromeDriver();
driver.get("https://example.com");

You can similarly use FirefoxDriver, EdgeDriver, etc.

driver.navigate().to("https://example.com");
driver.navigate().back();
driver.navigate().forward();
driver.navigate().refresh();

These mimic how users interact with a browser.

// Absolute XPath
/html/body/div[2]/input

// Relative XPath
//input[@id='username']

// Using contains
//input[contains(@id, 'user')]

// Using starts-with
//button[starts-with(@class, 'submit')]

This ensures selectors remain stable even if parts of the attribute values change.

• Implicit Wait: Waits for a defined time before throwing NoSuchElementException.
• Explicit Wait: Waits for a specific condition to occur.
• Fluent Wait: Offers more control over polling intervals and exception handling.

// Example of Explicit Wait
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement element = wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("login")));

• driver.close() – Closes the current browser window.
• driver.quit() – Quits the entire browser session, closing all associated windows and ending the WebDriver process.

Use quit() to ensure complete cleanup, especially after test suite execution.

File src = ((TakesScreenshot) driver).getScreenshotAs(OutputType.FILE);
FileUtils.copyFile(src, new File("screenshot.png"));

You can automate this on test failures using listeners or try-catch blocks.

ChromeOptions options = new ChromeOptions();
options.addArguments("--start-maximized");
WebDriver driver = new ChromeDriver(options);

Select select = new Select(driver.findElement(By.id("dropdownId")));
select.selectByVisibleText("Option 1");
select.selectByIndex(2);
select.selectByValue("opt2");

String parent = driver.getWindowHandle();
for (String handle : driver.getWindowHandles())  
// After actions, return to parent
driver.switchTo().window(parent);

driver.switchTo().frame("frameName");
// or
WebElement frame = driver.findElement(By.tagName("iframe"));
driver.switchTo().frame(frame);
// To return
driver.switchTo().defaultContent();

Alert alert = driver.switchTo().alert();
System.out.println(alert.getText());
alert.accept(); // or alert.dismiss();

You can also send text in prompt alerts using alert.sendKeys("text").

Actions actions = new Actions(driver);
WebElement element = driver.findElement(By.id("menu"));
actions.moveToElement(element).perform();

This is useful for revealing hidden dropdowns or tooltips.

List links = driver.findElements(By.tagName("a"));
for (WebElement link : links)  
}

• Hardcoded: Directly within test scripts (not scalable).
• External files: Excel, CSV, JSON, or XML using libraries like Apache POI or Jackson.
• DataProvider: In TestNG for parameterisation.

public class LoginPage  
}

It improves maintainability and readability.

try   catch (NoSuchElementException e)  

It’s a good practice to capture screenshots and continue test flow.

They help in better debugging and reporting mechanisms.

• Push Selenium scripts to a Git repository.
• Create a Jenkins job, link Git repo, and trigger builds.
• Use Maven/TestNG plugins for execution and reports.

This enables continuous testing and automated feedback loops.

There are several types of Selenium frameworks used in the industry:

• Data-Driven Framework: Focuses on externalising test data using Excel, CSV, or databases. Tests are driven by data rather than hard-coded inputs, increasing flexibility and reducing duplication.
• Keyword-Driven Framework: Uses predefined keywords (like click, input, verify) that are mapped to actions. Testers, even with limited coding skills, can write tests using these keywords in spreadsheets.
• Hybrid Framework: Combines the advantages of both Data-Driven and Keyword-Driven frameworks, allowing for greater flexibility and broader use-case coverage.

// Pseudocode for data-driven test
String username = excelReader.getCellValue("Sheet1", 1, 0);
driver.findElement(By.id("user")).sendKeys(username);

In the context of Selenium, TestNG plays a crucial role by organising test cases, supporting parallel execution, managing test dependencies, and generating detailed HTML reports. Its annotation-based structure allows developers to control the test lifecycle precisely.

Using TestNG with Selenium also provides seamless integration with tools like Maven, Jenkins, and Allure for CI/CD workflows.

@Test
public void testLogin()  

• @BeforeSuite and @AfterSuite: Run once before and after all tests in the suite.
• @BeforeClass and @AfterClass: Run once before and after each test class.
• @BeforeMethod and @AfterMethod: Run before and after each test method.
• @Test: Marks the actual test method.

This provides fine-grained control over how and when each piece of code is executed in relation to others.

@BeforeMethod
public void setup()  

@DataProvider(name="loginData")
public Object[][] getData()  ,
         
    };
}

@Test(dataProvider="loginData")
public void testLogin(String user, String pass)  

• TestNG provides built-in support for parallel test execution and dependency management, while JUnit requires external workarounds.
• Data-driven testing is more straightforward in TestNG using @DataProvider, whereas JUnit relies on parameterised test classes.
• TestNG’s reporting capabilities and annotations are more advanced and flexible compared to JUnit.

It enables separation of test logic, test data, and test keywords, resulting in reusable components and better collaboration between technical and non-technical team members.

The framework is ideal for large-scale applications where high flexibility and modularity are essential.

This can be achieved by using utility classes for common actions, following the Page Object Model to encapsulate page-specific behaviour, and ensuring that the test logic is kept separate from business logic.

Modularity allows teams to scale easily and maintain code with minimal effort.

• TestNG Reports: Provides HTML and XML reports by default.
• Extent Reports: Offers a rich UI with screenshots, logs, and status-based visuals for passed/failed/skipped tests.
• Allure Reports: Known for its modern interface, support for behavior-driven development (BDD), and CI integration.

<suite name="ParallelSuite" parallel="tests" thread-count="2">
  <test name="ChromeTests"> ... </test>
  <test name="FirefoxTests"> ... </test>
</suite>

By using tools like WebDriverManager, developers can automatically manage driver binaries. Parameterising the test suite using TestNG or configuration files allows you to run the same test across browsers.

if(browser.equals("chrome"))   else if(browser.equals("firefox"))  

By separating test logic from UI locators, it becomes easier to maintain the framework, especially when the UI changes frequently.

public class LoginPage  

  public void login(String user, String pass)  
}

Maven fetches them automatically, ensuring all team members use the same versions. Additionally, Maven helps in organising the project structure, running test suites via command line, and integrating with CI/CD pipelines like Jenkins.

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

By configuring Selenium projects as Jenkins jobs, testers can run their test suites automatically after every code check-in or at scheduled times.

It provides a dashboard to track pass/fail trends and supports plugin integration for reporting tools like Allure and Extent.

# Typical Jenkins setup:
- Pull latest code from GitHub
- Build project using Maven
- Run Selenium tests with TestNG
- Generate reports and email results

• Use Page Object Model to separate test logic from UI locators.
• Incorporate reusable utility methods for waits, logging, and assertions.
• Manage test data externally (Excel, JSON, or DB) using DataProviders.
• Use Maven or Gradle for build management.
• Integrate reporting tools like Extent or Allure for better visibility.
• Run tests in parallel to save time using TestNG or Selenium Grid.
• Handle exceptions gracefully and use proper logging mechanisms.

A Grid setup consists of a Hub (which controls execution) and multiple Nodes (which execute tests). Selenium Grid fits well in frameworks that need to validate UI behaviour across different environments simultaneously.

// Set desired capabilities for Firefox on Grid
DesiredCapabilities cap = DesiredCapabilities.firefox();
RemoteWebDriver driver = new RemoteWebDriver(new URL("http://localhost:4444/wd/hub"), cap);

Logger log = Logger.getLogger("MyLogger");
log.info("Login page opened successfully");

SoftAssert softAssert = new SoftAssert();
softAssert.assertEquals(title, "Dashboard");
softAssert.assertTrue(userIcon.isDisplayed());
softAssert.assertAll();

public class CustomListener extends TestListenerAdapter  
}

// testng.xml
<parameter name=\"browser\" value=\"chrome\"/>

// Test file
@Parameters(\"browser\")
public void setup(String browserName)  
}

// config.properties
browser=chrome
url=https://example.com

// Java code
Properties prop = new Properties();
prop.load(new FileInputStream(\"config.properties\"));
String baseUrl = prop.getProperty(\"url\");

String parent = driver.getWindowHandle();
Set<String> allWindows = driver.getWindowHandles();

for(String window : allWindows)  
}
driver.switchTo().window(parent);

// Using contains to match dynamic ID
WebElement loginBtn = driver.findElement(By.xpath("//button[contains(@id,'login')]"));

// Using wait
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement dynamicEl = wait.until(ExpectedConditions.elementToBeClickable(By.id("submit")));

driver.get("https://example.com/login");
driver.findElement(By.id("username")).sendKeys("testUser");
driver.findElement(By.id("password")).sendKeys("securePass123");
driver.findElement(By.id("loginButton")).click();

Make sure to replace IDs with actual locators for your application. Optionally, wrap this in a method for reusability.

List<WebElement> elements = driver.findElements(By.id("dashboard"));
if(elements.size() > 0) 

Avoid findElement() unless you’re certain the element exists, as it throws exceptions if not found.

WebElement uploadBtn = driver.findElement(By.id("uploadFile"));
uploadBtn.sendKeys("C:\\path\\to\\file.txt");

Always ensure the input field is visible and interactable.

File src = ((TakesScreenshot) driver).getScreenshotAs(OutputType.FILE);
FileUtils.copyFile(src, new File("screenshot.png"));

Integrate this into your test framework to capture screenshots automatically on test failure.

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

This is crucial in infinite scroll or lazy-load scenarios.

// Wrong: element = driver.findElement(By.id("status"));
// Later: element.click(); → Might throw stale exception

// Correct: Re-find element before use
element = driver.findElement(By.id("status"));
element.click();

Use try-catch or wait-and-retry logic to handle such cases gracefully.

WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement element = wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("submit")));

This avoids flaky tests caused by timing issues or JavaScript delays.

Alert alert = driver.switchTo().alert();
System.out.println(alert.getText());
alert.accept();

Make sure you switch back to the main content after handling the alert.

Select dropdown = new Select(driver.findElement(By.id("country")));
dropdown.selectByVisibleText("India");

Verify if the dropdown is a <select> element, otherwise you’ll need a custom XPath click.

List<WebElement> links = driver.findElements(By.tagName("a"));
System.out.println("Total links: " + links.size());

Use this in test scenarios for accessibility or SEO validation.

Actions action = new Actions(driver);
WebElement btn = driver.findElement(By.id("dblBtn"));
action.doubleClick(btn).perform();

Ensure the element is visible and interactable before performing the action.

WebElement source = driver.findElement(By.id("drag"));
WebElement target = driver.findElement(By.id("drop"));
Actions act = new Actions(driver);
act.dragAndDrop(source, target).perform();

public class LoginPage  
}

PageFactory.initElements(driver, this);

Unlike the traditional approach where elements are defined using driver.findElement(), Page Factory helps reduce boilerplate code and increases maintainability.

public class TestListener implements ITestListener  
}

Listeners help extend your framework with reporting, retry logic, and advanced debugging capabilities.

Logger log = Logger.getLogger("MyLogger");
log.info("Launching browser");
driver.get("https://example.com");

Proper logging provides transparency and helps reduce effort during failure analysis.

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

They help maintain cleaner projects and enable smooth collaboration among teams.

// Example using contains
driver.findElement(By.xpath("//button[contains(@id,'submit_')]")).click();

Additionally, we can use WebDriverWait to wait for a stable condition like visibility or clickability before interacting with dynamic elements.

• Set a custom download directory using Chrome/Firefox preferences.
• Use Java to check the file system after triggering download.

File dir = new File("C:/Downloads");
File[] files = dir.listFiles();
boolean found = Arrays.stream(files).anyMatch(f -> f.getName().equals("report.pdf"));

Combining browser config and post-download validation works best in automation pipelines.

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

This is especially useful in QA environments where valid certificates might not be installed.

• Use third-party libraries like AShot or Selenium 4’s dev tools API.
• For Firefox, full-page capture is native in headless mode.

driver = new FirefoxDriver();
driver.get("https://example.com");
File src = ((FirefoxDriver) driver).getFullPageScreenshotAs(OutputType.FILE);

Always validate browser support before using advanced capture methods.

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

This ensures visibility before interaction, especially on long pages or lazy-loaded content.

• driver.close() closes the current browser window that the WebDriver is controlling.
• driver.quit() shuts down all browser windows and ends the WebDriver session.

In multi-tab scenarios, close() is selective, while quit() ensures full cleanup of memory and resources.

Actions action = new Actions(driver);
action.dragAndDrop(source, target).build().perform();

If native drag-drop fails due to JavaScript handling, JS injection or robot class can be used as fallback.

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

For unexpected popups, add an explicit wait for ExpectedConditions.alertIsPresent().

HttpURLConnection conn = (HttpURLConnection) new URL(link).openConnection();
conn.setRequestMethod("HEAD");
conn.connect();
int respCode = conn.getResponseCode();

If response code is 400 or 500 series, it’s likely a broken link.

Connection con = DriverManager.getConnection(dbUrl, username, password);
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM users WHERE email='test@example.com'");

Always separate DB validation from UI logic using utility classes.

• Node registration errors or mismatched browser versions.
• Session timeouts due to remote driver instability.
• CI/CD integration flakiness with Dockerized Selenium Grid.

A well-maintained hub-node version match and retry logic in framework helps mitigate most problems.

ChromeOptions options = new ChromeOptions();
options.addArguments("--headless");
driver = new ChromeDriver(options);

Make sure you handle any UI operations differently as rendering may slightly differ.

public class RetryAnalyzer implements IRetryAnalyzer  
}

Attach it using @Test(retryAnalyzer = RetryAnalyzer.class) annotation.

Fixes include:

• Re-locate the element before using it again.
• Use explicit waits to wait for visibility before interaction.

long start = System.currentTimeMillis();
// Execute test
long end = System.currentTimeMillis();
System.out.println("Time taken: " + (end - start));

Such insights are essential for improving automation suite efficiency.