Explicit Waits & WebDriverWait

Target specific conditions with WebDriverWait for dynamic UI elements

Concept

Explicit waits are targeted waits that poll until a specific condition is true or timeout occurs.

Unlike implicit waits (which apply globally), explicit waits give you precise control over:

Which element or condition you're waiting for
How long to wait (timeout can vary per element)
What condition must be met (visible, clickable, text contains, etc.)

WebDriverWait

The WebDriverWait class is used to create explicit waits. It polls the DOM at regular intervals (default 500ms) until the Expected Condition is met or the timeout expires.

What it does

Creates a targeted wait that polls until a condition is true or timeout occurs.

WebDriverWait wait =
  new WebDriverWait(
    driver,
    Duration.ofSeconds(5)
  );

wait.until(
  ExpectedConditions
    .visibilityOf(element)
);

Waits up to 5 seconds for element to be visible

When to use it

Waiting for elements to appear or become visible
Elements that become clickable after some action
Text changes or content updates
Page title to contain specific value
Testing modern SPAs (React, Angular, Vue)

Best Practice

This is the recommended wait strategy for most modern web applications. More precise and readable than implicit waits.

Best Practice Notes

✓Use WebDriverWait + ExpectedConditions where things are known to be dynamic
✓Keep timeouts as small as realistically possible (3-10 seconds typically)
✓Reuse ExpectedConditions instead of writing custom lambdas for common scenarios
→Different elements can have different wait times based on their loading behavior

Interactive Practice

Imagine a page called "Dynamic Content Playground" with delayed elements:

Dynamic Content Playground

1. Add a Box section:

Box will appear 2 seconds after clicking the button

2. Reveal Input section:

Input will appear 2 seconds after clicking the button

3. Status Text:

Nothing done yet.

Interact with the buttons to see delayed elements appear, simulating dynamic content!

Manual interaction (what the student would do)

Click "Add a box!".
- Wait until the new box appears below.
- Confirm you see "I am a new box!".
Click "Reveal a new input".
- Wait until the text input is visible.
- Click the input and type: Displayed via waits.
Watch the Status Text update to: "Input filled: Displayed via waits".

Your Selenium code will use WebDriverWait + ExpectedConditions to wait for the box to exist and the input to be visible.

Java Code Example

ExplicitWaitExample.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
WebElement addBoxButton = driver.findElement(By.id("add-box-btn"));
WebElement revealInputButton = driver.findElement(By.id("reveal-input-btn"));

WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(5));

// 1. Click "Add a box!" and wait for the new box to exist in the DOM
addBoxButton.click();
WebElement dynamicBox = wait.until(
        ExpectedConditions.presenceOfElementLocated(By.id("dynamic-box"))
);

// 2. Click "Reveal a new input" and wait until the input is visible
revealInputButton.click();
WebElement revealedInput = wait.until(
        ExpectedConditions.visibilityOfElementLocated(By.id("revealed-input"))
);

// 3. Type into the revealed input
revealedInput.clear();
revealedInput.sendKeys("Displayed via waits");

driver.quit();

Code Breakdown

driver.findElement(By.id("add-box-btn")): Locates the "Add a box!" button using its id="add-box-btn".
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(5));: Creates an explicit wait that will wait up to 5 seconds for conditions to become true. This wait object can be reused for multiple conditions.
addBoxButton.click();: Clicks the Add a box button, triggering a delayed creation of the new box (~2 seconds).
wait.until(ExpectedConditions.presenceOfElementLocated(By.id("dynamic-box")));: Uses an Expected Condition to wait until a <div> with id="dynamic-box" exists in the DOM (even if it's not visible yet). Returns the element once it appears. Polls every 500ms until found or 5s timeout.
revealInputButton.click();: Clicks the Reveal a new input button to start the reveal animation.
wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("revealed-input")));: Waits until the text field with id="revealed-input" is present AND visible before proceeding. Note: visibilityOf is stricter than presenceOf—the element must have height/width and not be hidden.
revealedInput.clear(); revealedInput.sendKeys("Displayed via waits");: Clears any existing text and types "Displayed via waits" into the now-visible input. This updates the status text on the page.
driver.quit();: Closes the browser and ends the WebDriver session once all waiting scenarios have been executed.

Pro Tip

Use ExpectedConditions

Use explicit waits + ExpectedConditions for dynamic elements instead of Thread.sleep(...) – your tests become faster and more reliable.

Avoid Mixing Waits

Avoid mixing large implicit waits with explicit waits; rely mainly on explicit waits where needed. Combining them can lead to unexpected cumulative timeouts.

Reuse Wait Objects

Create one WebDriverWait instance and reuse it for multiple conditions. This keeps your code clean and reduces object creation overhead.