Selenium Interview Questions for 5 Years Experienced [2025]: Top 50

• Framework Type: Hybrid (Data + Keyword + POM)
• Language: Java (with Maven), occasionally Python for specific projects
• Test Runner: TestNG for Java projects, PyTest for Python
• Reporting: Extent Reports and Allure Reports for detailed HTML reports
• Build Tool: Maven or Gradle for dependency management
• CI/CD: Integrated with Jenkins for scheduled and triggered test runs
• Logging: Log4j for Java and Python logging module
• Parallel Execution: Implemented via TestNG XML and Selenium Grid

• Test Data Layer: Excel, JSON, or database sources
• Test Scripts: Modular test cases calling business functions
• Page Objects: Centralised element locators and methods per page
• Utilities: Custom libraries for waits, logs, screenshots
• Reporting: Automated report generation after test execution
• CI/CD Integration: Trigger points for Jenkins pipelines
• Exception Handling: Global error management for failed steps

public class LoginPage  

  public void login(String user, String pass)  
}

• src/main/java (or /python): Page Objects, Business Libraries
• src/test/java: Test scripts and runners
• Resources: Config files, test data files (Excel/JSON)
• Utils: Custom utilities for waits, screenshots, DB connections, reporting
• Logs: Runtime logs
• Reports: Auto-generated after execution
• Drivers: WebDriver binaries

• Launching browsers
• Logging in
• Reading test data
• Screenshot capture
• Common waits (Explicit, Fluent)

• INFO: Test steps
• DEBUG: For debugging failures
• ERROR: For capturing exceptions
• WARN: For flaky behavior or retry logic

• Extent Reports: For rich HTML reports with screenshots, step logs, and test status.
• Allure Reports: Used for CI environments with advanced categorisation and defect tracking.
• TestNG HTML Reports: As a lightweight backup option.

• TestNG Level: By setting parallel="tests" or parallel="methods" in TestNG XML.
• Grid Level: Using Selenium Grid or Dockerized Selenium Grid setup for cross-machine parallelism.

1. Trigger from Jenkins or command line (using Maven goals like clean test)
2. Tests run using TestNG/PyTest with desired suite (Smoke/Regression)
3. WebDriver and browser setup initialised via configuration files
4. Test data loaded from external sources
5. Page methods and utility functions invoked as per test flow
6. On test pass/fail, reports updated and screenshots captured for failures
7. Post-execution: Reports archived, logs saved, and email/Slack notifications triggered

• Implicit Wait: Applies a default wait time for every element search. Not specific to any element. Not recommended for complex scenarios.
• Explicit Wait: Targets specific elements with custom wait conditions like visibility, clickability, etc. Allows better control for dynamic elements.
• Fluent Wait: Extends Explicit Wait by adding polling frequency and exception ignoring. Best for elements that load intermittently or have unstable behavior.

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

wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("username")));

• Always use Explicit Waits instead of Thread.sleep()
• Implement custom wait wrappers for recurring elements
• Utilise polling with Fluent Wait for elements with unpredictable load times
• Use ExpectedConditions for clickability and visibility checks
• Monitor failed tests and adjust locator strategies for dynamic elements
• Configure retry logic for known flaky scenarios (using RetryAnalyzer in TestNG)

• Standard Selenium click or sendKeys fails due to frontend JS issues
• Elements are hidden behind overlays or modals
• Page has heavy AJAX loading, causing element state inconsistencies

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

driver.manage().timeouts().pageLoadTimeout(Duration.ofSeconds(30));

• Set timeouts based on application SLAs
• Log timeout exceptions for root cause analysis
• Combine with network stubbing tools during testing if possible

• I use Explicit Wait with ExpectedConditions.presenceOfElementLocated() or visibilityOfElementLocated()
• In case of loading spinners, I wait until spinner becomes invisible before interacting with elements
• For highly dynamic AJAX content, I sometimes use Fluent Wait with polling

WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(20));
wait.until(ExpectedConditions.invisibilityOfElementLocated(By.id("loader")));

• Create a DataProvider method returning Object[][] from Excel, CSV, or JSON
• Link the DataProvider to your test method using @Test(dataProvider = "name")
• Use Apache POI to fetch data dynamically from Excel files

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

FileInputStream fis = new FileInputStream("TestData.xlsx");
Workbook wb = new XSSFWorkbook(fis);
Sheet sheet = wb.getSheet("LoginData");
String username = sheet.getRow(1).getCell(0).getStringCellValue();

• Externalise file path and sheet name in config files
• Use data utility methods for cleaner test scripts
• Implement null/empty cell handling to prevent runtime failures

• Test Data Source: Excel sheet mapping keywords to actions
• Driver Script: Reads keywords and executes corresponding Selenium functions
• Keyword Library: Reusable methods for each supported action

• When business teams want to define test flows without coding
• For projects with repetitive business flows
• When non-technical stakeholders contribute to test case design

• Properties Files: For Java-based frameworks
• config.yaml or .ini Files: For Python frameworks
• Environment Variables: For CI/CD builds to handle sensitive data like credentials
• JSON/Excel: For storing environment-specific URLs, timeouts, and browser types

Properties prop = new Properties();
FileInputStream fis = new FileInputStream("config.properties");
prop.load(fis);
String url = prop.getProperty("baseUrl");

• TestNG Parameters: Using @Parameters annotation with TestNG XML
• DataProvider: For multiple data rows
• Jenkins Job Parameters: For environment-specific execution in CI/CD
• Command Line Arguments: Using Maven command line options (e.g., -Dbrowser=chrome)

<parameter name="browser" value="chrome"/>

• Define browser type in TestNG XML, Maven profile, or Jenkins build parameter
• Use conditional logic inside browser factory classes to launch Chrome, Firefox, or Edge
• Use WebDriverManager to manage browser driver binaries automatically

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

• Identifying target browsers based on business requirements (Chrome, Firefox, Edge, Safari)
• Maintaining a browser compatibility matrix documenting supported versions
• Running smoke and regression tests across all supported browsers before major releases
• Using Selenium Grid or cloud platforms like BrowserStack for scalable testing across multiple OS-browser combinations

<suite name="ParallelTests" parallel="methods" thread-count="5">
  <test name="CrossBrowserTest">
    ...
  </test>
</suite>

• Use ThreadLocal WebDriver instances to avoid session conflicts
• Ensure test data isolation for parallel-safe execution
• Configure timeouts carefully to avoid thread blocking

• Use official Selenium Docker images (Hub and Node images)
• Write a docker-compose.yml file to orchestrate Hub and Nodes
• Expose necessary ports for communication
• Run the Grid locally or deploy on cloud infrastructure

• Scalability with minimal infrastructure setup
• Quick teardown and redeployment
• Consistent execution environment

• Sign up and generate access credentials (Username and Access Key)
• Modify Selenium RemoteWebDriver configurations to point to the cloud grid URL
• Configure desired capabilities like OS, browser version, and resolution
• Integrate cloud dashboard URLs into Selenium test reports for traceability

DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability("browserName", "chrome");
caps.setCapability("browserVersion", "latest");
driver = new RemoteWebDriver(new URL("https://hub.browserstack.com/wd/hub"), caps);

• Check out source code from Git during Jenkins build
• Invoke Maven commands like clean test for Java projects or use shell scripts for Python-based projects
• Configure Jenkins to archive TestNG or JUnit XML reports after execution
• Integrate email or Slack notifications for build status
• Trigger jobs on specific Git branches or based on pull requests

• Manage dependencies via pom.xml
• Define test execution goals like clean test
• Configure Surefire plugin for parallel execution and reporting
• Integrate Maven with Jenkins jobs for automated triggers

• Use requirements.txt for dependency management
• Run PyTest commands with XML report generation for Jenkins compatibility

• JUnit Plugin: For parsing TestNG or JUnit XML result files
• HTML Publisher Plugin: For publishing Extent Reports or Allure Reports as clickable build artifacts
• Post-Build Actions: For emailing report links to stakeholders
• Build Status Indicators: Using color-coded build status on Jenkins dashboards based on pass/fail ratios

• Set Jenkins to listen for Git repository changes
• Trigger jobs on push events or pull requests
• Configure branch filters to run tests only on specific branches (e.g., develop, release)
• Integrate code quality gates (SonarQube) to run pre-test checks before Selenium execution

• Jenkins Build Parameters: Predefined environment selectors (e.g., QA, UAT, Production)
• System Properties (Java): Passed using Maven command line (e.g., -Denv=QA)
• Environment Variables: For sensitive info like DB passwords or tokens
• Config Files: Use separate config files per environment and load them dynamically in Selenium code

mvn clean test -Denv=UAT

• Preserving login sessions across tests
• Manipulating cookies for testing personalization or geo-targeting
• Clearing cookies between tests for environment isolation

Cookie ck = new Cookie("userToken", "xyz123");
driver.manage().addCookie(ck);
driver.manage().deleteAllCookies();

• Store the main window handle
• Trigger the new tab or window
• Switch WebDriver context using the window handle iterator
• Perform actions, then switch back

String parent = driver.getWindowHandle();
Set<String> allWindows = driver.getWindowHandles();
for (String window : allWindows)  
}

driver.findElement(By.id("uploadBtn")).sendKeys("C:\\path\\to\\file.pdf");

• I configure browser profiles (like ChromeOptions) to set default download directories
• Use headless browser modes for CI environments
• For validating downloaded files, I check file presence and content in the download folder

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

• Capture screenshots on every test failure using TestNG Listeners or PyTest hooks
• Integrate screenshot links into Extent or Allure reports for traceability
• For parallel runs, add unique timestamp or thread ID to filenames

• Switch control to the alert using switchTo().alert()
• Use accept(), dismiss(), or getText() based on test requirement
• For modal dialogs (HTML-based), locate and interact with DOM elements

Alert alert = driver.switchTo().alert();
alert.accept();

JavascriptExecutor js = (JavascriptExecutor) driver;
WebElement shadowHost = driver.findElement(By.cssSelector("#shadowHost"));
WebElement shadowRoot = (WebElement) js.executeScript("return arguments[0].shadowRoot", shadowHost);

• Access shadowRoot using JSExecutor
• Then locate child elements within the Shadow DOM

• contains() for partial attribute matches
• starts-with() for attribute prefixes
• text() for text-based element selection
• Parent/child/sibling axes for navigating DOM structure

//button[contains(text(),'Submit')]

• Refetching the WebElement before interaction
• Using Explicit Wait to ensure element state is stable
• Encapsulating element actions inside retry blocks
• Waiting for page refresh or DOM reload completion

try   catch (StaleElementReferenceException e)  

• Uses annotations like @FindBy
• Loads elements only when called
• Supports page object encapsulation

PageFactory.initElements(driver, LoginPage.class);

• Implement parallel test execution using TestNG or Selenium Grid
• Run only selected test groups for faster feedback
• Minimise use of Thread.sleep()
• Reuse browser sessions where appropriate
• Use headless browser modes for CI builds
• Implement retry logic for known flaky scenarios
• Optimise XPath and CSS locators for speed

• I replaced static XPath locators with dynamic XPath using contains() and starts-with() functions.
• Introduced Explicit Waits to ensure element presence.
• Created a custom locator utility class to standardise dynamic locator creation across the framework.

• I enabled parallel test execution at the method and class level using TestNG
• Reduced page object initialization overhead by introducing lazy loading
• Replaced hard waits with optimized Explicit and Fluent Waits
• Switched from HTML reports to lightweight JSON reporting for faster I/O
• Ran sanity and smoke suites on every build, while keeping full regression for nightly runs

• Comprehensive suite covering all core functionalities
• Executed before major releases
• Focus on checking for code regressions across modules

• Lightweight suite covering critical paths (e.g., login, checkout)
• Executed on every build to validate basic system stability
• Acts as a deployment gate for further testing

• I categorize tests into groups (@Test(groups = ))
• Maintain separate TestNG XMLs for smoke and regression runs

• Implemented retry logic using TestNG RetryAnalyzer
• Introduced stabilised wait strategies (avoiding Thread.sleep())
• Set up test failure categorisation (Infrastructure issue vs Code defect)
• Logged flaky tests separately for monitoring and analysis
• Reviewed and refactored unreliable locators and test logic

• Our cross-browser automation suite flagged the Chrome-specific failure
• The issue was traced to a JavaScript browser compatibility bug
• We raised a P1 defect, preventing a production release delay and potential revenue loss
• After the fix, the Selenium suite validated the patch across all browsers before deployment

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

• Click the dropdown element
• Use XPath or CSS selectors to locate and click the desired option

List<WebElement> rows = driver.findElements(By.xpath("//table[@id='dataTable']/tbody/tr"));
List<WebElement> cols = driver.findElements(By.xpath("//table[@id='dataTable']/tbody/tr[1]/td"));

for (int i = 1; i <= rows.size(); i++)  
}

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

@Test(dataProvider = "loginData")
public void loginTest(String username, String password)  

Screenshot screenshot = new AShot().shootingStrategy(ShootingStrategies.viewportPasting(1000)).takeScreenshot(driver);
ImageIO.write(screenshot.getImage(), "PNG", new File("fullpage.png"));

• Use ChromeOptions and DevTools API for full-page screenshots

List<WebElement> links = driver.findElements(By.tagName("a"));

for (WebElement link : links)  
  } catch (Exception e)  
}