Interview Round

Focus Area

Typical Duration

Aptitude / Written Test

Basic programming logic, QA concepts

30-45 min

Technical Round 1

Selenium WebDriver, locators, waits, basic Java

45-60 min

Technical Round 2

TestNG, frameworks, POM, Selenium Grid, assertions

60 min

Practical / Coding Round

Write a test script live or solve automation scenario

30-45 min

HR Round

Team fit, career goals, salary expectations

20-30 min

Question

Answer

What is Selenium WebDriver and how does it differ from Selenium RC?

Selenium WebDriver directly communicates with browsers through browser-native drivers (ChromeDriver, GeckoDriver, etc.) using the W3C WebDriver protocol. There is no server intermediary needed. Selenium RC (Remote Control) required a Java server between the test script and the browser. WebDriver is faster, more stable, and supports modern browsers and JavaScript-heavy applications better than RC.

How does Selenium WebDriver communicate with browsers internally?

When you call a WebDriver method like driver.findElement(), it sends an HTTP request in JSON Wire Protocol (or W3C WebDriver Protocol from Selenium 4) to the browser driver executable. The browser driver (e.g., ChromeDriver) translates these commands into browser-native instructions. The browser executes them and returns the result back through the driver to your test code.

What browsers does Selenium WebDriver support?

Selenium WebDriver supports Chrome (ChromeDriver), Firefox (GeckoDriver), Edge (EdgeDriver), Safari (SafariDriver), Opera, and Internet Explorer. Selenium 4 uses the W3C-compliant WebDriver standard, which all major browsers implement. You can also use HTMLUnit for headless testing and connect to remote browsers via Selenium Grid or cloud services like Sauce Labs and BrowserStack.

What is the difference between driver.close() and driver.quit()?

driver.close() closes only the currently focused browser window or tab. If multiple windows are open, the others remain. driver.quit() closes ALL browser windows opened during the session and terminates the WebDriver process entirely. In teardown methods, always use driver.quit() to prevent orphaned browser processes from accumulating on the machine.

What are the different types of driver initialization in Selenium 4?

Selenium 4 introduced WebDriverManager-style automatic driver management via Selenium Manager. You can now create ChromeDriver with just new ChromeDriver() without manually setting the driver path. Older approaches used System.setProperty() with a downloaded driver binary. Selenium 4 also supports the new DevTools Protocol for Chrome-specific debugging via ChromeDriver’s CDP (Chrome DevTools Protocol) integration.

Method / Concept

What It Does

Code Pattern

driver.get(url)

Opens URL and waits for page load event

driver.get(“https://example.com”);

driver.navigate().to(url)

Opens URL without waiting for full load

driver.navigate().to(url);

driver.navigate().back()

Browser back button action

driver.navigate().back();

driver.navigate().refresh()

Refreshes current page

driver.navigate().refresh();

driver.getWindowHandles()

Returns all window/tab handles as Set<String>

Set<String> h = driver.getWindowHandles();

driver.switchTo().window(handle)

Switches focus to specified window

driver.switchTo().window(newHandle);

driver.switchTo().frame()

Switches to an iframe by index, name, or WebElement

driver.switchTo().frame(“frameName”);

driver.switchTo().alert()

Switches to a JavaScript alert/confirm/prompt

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

Locator Type

Best For

Performance

Readability

Fragility

ID

Unique element identification

Fastest

Excellent

Low (if IDs are stable)

Name

Form elements

Fast

Good

Low-Medium

Class Name

Groups of similar elements

Fast

Good

Medium (classes change)

Tag Name

Finding all elements of a type

Fast

Good

High (too broad)

Link Text

Anchor tags by exact text

Fast

Excellent

Medium (text can change)

CSS Selector

Complex selections without DOM traversal

Fast

Good

Medium

XPath

Complex traversal, text-based, dynamic elements

Slower

Moderate

Medium-High

Question

Answer

What is the difference between absolute and relative XPath?

Absolute XPath starts from the root HTML element and traces the full DOM path: /html/body/div[1]/form/input. It breaks whenever any element in the chain changes. Relative XPath starts from any point in the DOM using // and is much more robust: //input[@id=’username’]. Always prefer relative XPath. Absolute XPath is generally considered a test automation anti-pattern.

What is the difference between single slash (/) and double slash (//) in XPath?

Single slash / selects a direct child element at that specific level in the hierarchy. Double slash // selects matching elements anywhere in the document or subtree regardless of depth. //input[@type=’text’] finds all text inputs anywhere in the page. //div/input finds input elements that are direct children of any div element anywhere.

What are the most useful XPath functions in Selenium?

contains(): //button[contains(text(),’Submit’)] – partial text match. starts-with(): //input[starts-with(@id,’user’)] – ID prefix match. text(): //h1[text()=’Login’] – exact text match. normalize-space(): handles leading/trailing whitespace. last(): //tr[last()] – last row. position(): //li[position()<3] – first two list items. These are tested frequently in selenium xpath interview questions.

What is Axes in XPath?

XPath axes define the direction of traversal from the context node. Key axes: following-sibling (same parent, after current), preceding-sibling (same parent, before current), parent (direct parent), ancestor (all parents up to root), descendant (all children recursively), and self (current node). Example: //label[text()=’Email’]/following-sibling::input finds the input next to an ‘Email’ label.

Feature

CSS Selector

XPath

Syntax

Shorter and cleaner

More verbose

Speed

Faster in most browsers

Slightly slower

Text-based matching

Not supported

Fully supported via text()

Traversal direction

Forward only (child, descendant)

Both forward and backward (parent, ancestor)

Browser support

Universally supported

Universally supported

Dynamic attributes

Limited

Powerful with contains(), starts-with()

Best use case

Well-structured pages with stable classes/IDs

Dynamic content, no IDs, text-based matching

Annotation

Scope

Execution Trigger

Common Use Case

@BeforeSuite

Suite

Before entire test suite

Initialize global config, logging, reporting

@BeforeTest

Test tag in XML

Before each <test> tag

Set browser profile, test-level config

@BeforeClass

Class

Before first method in class

Launch browser instance for the class

@BeforeMethod

Method

Before each @Test method

Navigate to base URL, clear cookies

@Test

Method

Test execution

Actual test logic

@AfterMethod

Method

After each @Test method

Take screenshot on failure, log result

@AfterClass

Class

After last method in class

Close browser instance

@AfterTest

Test tag in XML

After each <test> tag

Clean up test-level resources

@AfterSuite

Suite

After entire test suite

Generate Extent Report, notify

Question

Answer

What is the execution order of TestNG annotations?

@BeforeSuite -> @BeforeTest -> @BeforeClass -> @BeforeMethod -> @Test -> @AfterMethod -> @AfterClass -> @AfterTest -> @AfterSuite. For multiple @Test methods in one class: @BeforeMethod and @AfterMethod wrap each test. @BeforeClass runs once before all tests in the class. @BeforeTest wraps all classes within a <test> XML tag.

What is @DataProvider in TestNG?

@DataProvider is a TestNG annotation that provides multiple sets of test data to a @Test method. It returns Object[][] where each inner array is one test run. The test method runs once for each row of data. It enables data-driven testing without duplicating test methods. Example: @DataProvider(name=’loginData’) providing username/password combos runs the login test for each credential pair.

What is the difference between hard assertion and soft assertion?

Hard Assert (Assert class) stops test execution immediately when the assertion fails – the rest of the test does not run. Soft Assert (SoftAssert class) collects all assertion failures and reports them together at the end when assertAll() is called. Use hard assertions for critical checkpoints where proceeding makes no sense. Use soft assertions when you want to verify multiple conditions and see all failures in one run.

How do you run tests in parallel with TestNG?

Set parallel=’tests’ (or ‘classes’ or ‘methods’) and thread-count in your testng.xml file. Each thread runs tests independently. When running parallel tests with Selenium, use ThreadLocal<WebDriver> to give each thread its own driver instance, preventing threads from interfering with each other’s browser session. This is a common design question in senior selenium with java interview questions.

Question

Answer

What is the Page Object Model (POM) in Selenium?

POM is a design pattern where each web page or page section has a corresponding Java class. The class contains all element locators and methods to interact with those elements. Test scripts call these page methods instead of writing locators directly. This separates test logic from UI interaction code, making tests more readable, reusable, and maintainable when the UI changes.

What is Page Factory and how does it differ from POM?

Page Factory is an implementation of POM provided by Selenium’s PageFactory class. It uses @FindBy annotations to declare web element locators as class fields, and PageFactory.initElements() initializes them lazily. Regular POM stores WebElement locators as By objects or finds elements in each method. Page Factory is more concise but both implement the POM pattern. @FindBy is evaluated each time the field is accessed.

Why is POM important in selenium framework interview questions?

Without POM, locator changes require updates across dozens of test methods. With POM, you change one line in the page class and all tests using that page are fixed. POM also makes tests readable: loginPage.enterUsername(‘admin’) is far clearer than driver.findElement(By.id(‘usr’)).sendKeys(‘admin’). Interviewers ask about POM because it signals that a candidate can build maintainable automation at scale.

What is a Hybrid Framework in Selenium?

A Hybrid Framework combines data-driven, keyword-driven, and object-oriented approaches. Test data comes from external sources like Excel or JSON. Keywords represent actions (click, enter, verify). Page Object Model handles element interaction. Utility classes handle cross-cutting concerns like reporting and screenshot capture. Most enterprise automation projects use hybrid frameworks because no single approach covers all use cases.

Question

Answer

What is a Data-Driven Framework?

A data-driven framework separates test data from test logic. Test scripts read input values and expected results from external sources (Excel, CSV, JSON, databases) and execute the same test logic for multiple data sets. Apache POI is the standard Java library for reading/writing Excel files in Selenium projects. This eliminates hardcoded data and makes running regression tests with varied inputs easy.

How do you read data from an Excel file in Selenium?

Use Apache POI library. Add the dependency in pom.xml. Use FileInputStream to open the .xlsx file, create a Workbook with WorkbookFactory.create(), access the sheet by name, iterate rows and cells. Example: Row row = sheet.getRow(1); Cell cell = row.getCell(0); String value = cell.getStringCellValue(). Combine with @DataProvider to pass the data directly to TestNG test methods.

Wait Type

Defined By

Scope

Throws After Timeout

Best For

Thread.sleep()

Java (not Selenium)

Fixed pause

No timeout – just sleeps

Never use in production tests

Implicit Wait

driver.manage().timeouts()

All findElement calls globally

NoSuchElementException

Simple cases, uniform wait needs

Explicit Wait

WebDriverWait + ExpectedConditions

Specific element or condition

TimeoutException

Dynamic content, AJAX elements

Fluent Wait

FluentWait builder

Specific element with polling interval

TimeoutException

Elements that appear intermittently

Question

Answer

What is Implicit Wait in Selenium?

Implicit wait sets a global timeout for the entire WebDriver session. If driver.findElement() does not find the element immediately, WebDriver polls the DOM at regular intervals until the element appears or the timeout expires. Set once: driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10)). The downside: it applies to all findElement calls, which can slow tests down when elements genuinely do not exist.

What is Explicit Wait and how does it work?

Explicit wait waits for a specific condition to be true before proceeding. Use WebDriverWait with ExpectedConditions. Example: new WebDriverWait(driver, Duration.ofSeconds(10)).until(ExpectedConditions.visibilityOfElementLocated(By.id(‘btn’))). This is the preferred approach because you wait only when needed, for exactly the condition you care about. It does not affect other findElement calls.

What is Fluent Wait?

FluentWait is a customizable explicit wait where you set the maximum wait time, the polling interval (how often to check), and which exceptions to ignore during polling. Example: polling every 500ms while ignoring NoSuchElementException. It is ideal for elements that load after an animation or that appear and disappear unpredictably. It gives you the finest control over wait behavior.

Can you mix implicit and explicit waits?

You should not mix them. Selenium documentation explicitly warns that combining implicit and explicit waits can cause unpredictable wait times because they interact in complex ways at the WebDriver level. In practice, most frameworks pick one strategy: either set a global implicit wait OR use explicit waits everywhere. Explicit waits are generally preferred in professional test frameworks for their precision.

Question

Answer

What is Selenium Grid?

Selenium Grid allows you to run Selenium tests on multiple machines and browsers simultaneously. A Hub acts as a central server that receives test requests. Nodes are machines connected to the Hub that run actual browser instances. Tests are distributed across nodes, dramatically reducing total execution time for large suites. Cloud services like Sauce Labs and BrowserStack are essentially hosted Selenium Grids.

What changed in Selenium Grid 4?

Selenium 4 introduced a completely redesigned Grid with no separate Hub/Node installation. A single grid.jar file handles everything. It added a new Router, Distributor, Session Map, and Event Bus architecture for better scalability and observability. Selenium Grid 4 also supports Docker out of the box and has a much improved Web UI dashboard for monitoring test sessions in real time.

What is a DesiredCapabilities or Options object in Selenium Grid?

DesiredCapabilities (older API) or Options classes (ChromeOptions, FirefoxOptions – modern API) specify what type of browser and OS you want for a remote test. When submitting to Grid, the Distributor finds a matching Node and routes your test there. Example: ChromeOptions options = new ChromeOptions(); driver = new RemoteWebDriver(new URL(gridUrl), options) sends the test to a Chrome-capable node.

Question

Answer

How do you handle dynamic web elements in Selenium?

Use dynamic XPath strategies: contains() for partial attribute values, starts-with() for attribute prefixes, and following-sibling/preceding-sibling axes to locate elements relative to stable neighbors. For elements that appear after actions (AJAX responses), use explicit waits with ExpectedConditions.visibilityOf() or presenceOfElementLocated(). Avoid hardcoded indices in locators as they are highly fragile.

How do you take screenshots in Selenium?

Cast driver to TakesScreenshot, then call getScreenshotAs(OutputType.FILE) or OutputType.BYTES. Example: File screenshotFile = ((TakesScreenshot)driver).getScreenshotAs(OutputType.FILE); FileUtils.copyFile(screenshotFile, new File(‘screenshot.png’)). For test framework integration, call this in @AfterMethod with ITestResult to automatically capture screenshots only on test failures using TestNG listeners.

What is the Actions class in Selenium?

Actions class handles complex user gestures that cannot be done with simple click/sendKeys. Common operations: hover (moveToElement), right-click (contextClick), double-click (doubleClick), drag and drop (dragAndDrop), keyboard actions (keyDown, keyUp), and chained action sequences. Always end the chain with build().perform(). Example: new Actions(driver).moveToElement(menu).click(subItem).build().perform();

How do you handle a dropdown in Selenium?

For standard HTML <select> elements, use the Select class: Select sel = new Select(driver.findElement(By.id(‘dropdown’))). Methods: selectByVisibleText(), selectByValue(), selectByIndex(), getOptions(), getFirstSelectedOption(). For custom dropdowns (div/ul-based), click the dropdown trigger to open it, then click the desired option using findElement. Never use Select for non-standard dropdowns.

What is a Listener in TestNG and Selenium?

Listeners implement ITestListener or IInvocationListener interfaces to hook into the test lifecycle. onTestStart(), onTestFailure(), onTestSuccess() methods fire at each event. Common uses: taking screenshots on failure, logging test results, sending Slack notifications, and initializing reporting. Register listeners in testng.xml or via @Listeners annotation on the test class.

Assertion Method

What It Checks

Hard or Soft

Throws If Fails

Assert.assertEquals(actual, expected)

Exact equality of two values

Hard

AssertionError – stops test

Assert.assertNotEquals(actual, expected)

Two values are NOT equal

Hard

AssertionError – stops test

Assert.assertTrue(condition)

Boolean condition is true

Hard

AssertionError – stops test

Assert.assertFalse(condition)

Boolean condition is false

Hard

AssertionError – stops test

Assert.assertNull(object)

Object reference is null

Hard

AssertionError – stops test

Assert.assertNotNull(object)

Object reference is not null

Hard

AssertionError – stops test

softAssert.assertEquals()

Equality – records failure without stopping

Soft

Only at softAssert.assertAll()

softAssert.assertAll()

Reports all collected soft assertion failures

Soft

AssertionError with all failures

Phase

Focus

Duration

Key Outcome

Phase 1: Foundation

Java basics (OOPs, exceptions, collections), Selenium setup, basic test scripts

Week 1-2

Can write a simple login test from scratch

Phase 2: Locators & Waits

XPath, CSS selectors, all wait types, dynamic element handling

Week 3

Can locate any element and write stable waits

Phase 3: TestNG Mastery

All annotations, DataProvider, parallel execution, assertions, listeners

Week 4

Can run parameterized parallel test suites

Phase 4: Frameworks

Page Object Model, Page Factory, Hybrid Framework, Extent Reports

Week 5

Can design a POM-based project from scratch

Phase 5: Interview Practice

Mock questions, explain code aloud, scenario-based problems

Week 6

Confident verbal explanations of all concepts