Recommended Free Tools
A Selenium test that passes sometimes and fails at other times is showing a symptom, not naming its cause. Start by capturing the first failure and sorting it into a timing, test-isolation, or browser/driver problem; then change the part the evidence points to. Selenium identifies poor synchronization as its most common Selenium-related error cause, but driver and environment issues can also be involved. Selenium troubleshooting guidance and its waiting guide support diagnosing the failure rather than blindly increasing timeouts or hiding it with retries.
Capture the failure before changing the test
Keep the first failed run’s context. A retry that passes does not explain the original failure, and changing several things at once makes it harder to identify the cause.
- Record the test name, exact failed command, exception, and relevant browser or driver logs.
- Record the Selenium, browser, and driver versions and whether the run was local or in CI.
- Note whether the same test fails when run alone, only after another test, only in parallel, or only in one browser.
- If your logging setup supports it, preserve the command sequence and failure-time browser state, such as a screenshot or page details.
Selenium’s troubleshooting material recommends using logs and comparing behavior across browsers when a driver-specific problem is possible. An exception can narrow the investigation, but it does not prove there is only one possible cause.
Classify the failure pattern
| What you observe | First hypothesis to test | Useful next check |
|---|---|---|
| An element is missing, not yet visible, or stale around a page update | The test may be acting before the application reaches the needed state. | Identify the exact state required for the next action or assertion, then wait for that condition. |
| The test passes alone but fails after another test, or behaves differently depending on order | Tests may share browser, account, data, or other state, or cleanup may be incomplete. | Run the test with its own setup and inspect what the preceding test leaves behind. |
| The same operation fails consistently in one browser or driver combination | A browser, driver, or environment difference may be involved. | Compare the same operation in another browser and capture version and log details. |
| The failure appears only in CI or under parallel execution | There may be an environment difference or shared resource, in addition to any timing issue. | Compare the recorded browser/driver context and execution conditions with an isolated run. |
These patterns guide investigation; they are not exclusive diagnoses. A state leak can look timing-related, and an environment difference can expose a race that is harder to trigger locally.
The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →#1 Best Overall
Fix synchronization by waiting for the state you need
A completed navigation does not guarantee that a JavaScript application is ready for the next test command. Selenium’s navigation waits correspond to a document readyState; the application may still add elements, update content, or change visibility afterward. Selenium’s waiting guide calls race conditions—commands running before the browser reaches the needed state—“one of the primary causes of flaky tests.”
Use a condition-based explicit wait
Wait for the specific state needed by the next step, such as an element becoming visible or clickable, rather than sleeping for an arbitrary interval. In Python, the pattern looks like this:
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import WebDriverWait
# driver is an already-created WebDriver.
button = WebDriverWait(driver, 10).until(
EC.element_to_be_clickable((By.CSS_SELECTOR, "button.submit"))
)
button.click()The selector and condition above are examples; use the locator and UI condition that match your application. Choose a timeout that reflects the application’s expected behavior and the suite’s constraints. Selenium does not prescribe one universal timeout for every application.
Rank #2
Do not mix implicit and explicit waits
Selenium warns that combining implicit and explicit waits can produce unpredictable timeout behavior. If a test uses explicit waits for specific state changes, avoid also setting a broad implicit wait that alters element lookup timing. Make the suite’s waiting strategy clear and consistent.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Use sleeps only as a diagnostic experiment
Selenium’s troubleshooting guidance notes that a deliberately long sleep can help test whether synchronization is involved. If the test begins passing, treat that as evidence of a timing hypothesis—not as a finished fix. Replace the sleep with a wait for the meaningful UI condition, so the test proceeds as soon as that condition is met instead of consuming a fixed delay on every run.
Make each test independent and smaller
A test whose outcome depends on another test’s setup or cleanup is vulnerable to order and parallel-run differences. Give each test the data and state it needs, and avoid relying on a previous test to leave the browser or application in a particular condition.
- Set up the test’s required data and state explicitly.
- Keep browser scenarios short and focused on one behavior.
- Give each test a clear driver lifecycle and quit the driver after the test.
- Check that cleanup does not leave state that affects later tests.
- Move checks that do not need a real browser to a lighter test layer; reserve browser tests for behavior that depends on browser interaction.
Selenium’s guidance on test scope and avoiding shared state supports keeping end-to-end tests discrete and independent. Smaller, isolated cases are also easier to reproduce when a failure occurs.
Check browsers, drivers, CI, and parallel execution
If timing and test coupling do not explain the failure, compare the same operation across the environments where it does and does not occur. Preserve version and log details so a browser-specific signature is distinguishable from a general test defect.
Free tools Windows power users keep installed
One-click scans. No signup required.
- Run the failing test by itself and note the exact browser, driver, Selenium version, and execution environment.
- Where practical, repeat the same operation in another browser. A failure isolated to one browser/driver combination is a reason to investigate that combination, not to conclude immediately that Selenium itself is defective.
- Compare local and CI runs, including whether they use the same browser/driver context and test data.
- For parallel runs, check whether tests share accounts, data, or other resources and whether each test owns its driver.
- If you need deliberate multi-machine or parallel browser coverage, Selenium Grid is an execution option; it does not repair a race or state leak in the test itself. See the Selenium Grid documentation.
Use retries as a signal, not a fix
A test that passes on retry has demonstrated intermittency; it has not identified why the first run failed. Keep the original failure and retry result visible in reporting, and use them to guide investigation. A retry policy may affect how a suite handles transient failures, but no universal retry count is established as a cure for flaky Selenium tests.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Troubleshooting common failure patterns
Wait times out while looking for an element
Check whether the locator is correct and whether the application reached the expected state at all. If the element is added asynchronously, wait for the relevant condition. If the test uses both implicit and explicit waits, remove the ambiguity and use a consistent strategy.
Element becomes stale during an update
A page update may replace the element between locating it and using it. Identify the update boundary, then wait for the post-update state and locate the element in that state rather than relying on an earlier reference.
A long sleep makes the test pass
That points toward synchronization as a possibility, but it is inefficient and can still fail if the delay is insufficient. Replace it with an explicit wait for the state the test actually needs.
Failure depends on test order
Run the case independently, inspect its setup and teardown, and check for shared browser or application state. Make the test establish its own prerequisites and close its own driver.
Failure appears in one browser or only in CI
Compare browser, driver, Selenium version, logs, and execution conditions between passing and failing runs. Gather evidence before changing infrastructure; adding Grid capacity will not resolve an underlying synchronization or isolation defect.
A retry passes but the first attempt fails
Preserve both outcomes and the first exception. Use the intermittent pattern as a clue, then classify it by timing, state/order, or environment instead of treating retry success as proof of reliability.
Or skip the browser setup
If your immediate need is a clean screenshot of a page rather than an interactive Selenium test, ScreenshotNeo is a website screenshot API and MCP server. One GET request returns a screenshot or PDF; its clean-shot steps accept cookie/consent banners like a visitor and remove more than 60 known consent platforms, newsletter popups, and chat widgets, with each step optional.
Example cURL request (see the ScreenshotNeo API documentation for parameters):
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpScreenshotNeo’s response identifies page verdict and billing status in headers; bot checks/CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing. Its MCP server exposes take_screenshot, get_page_info, and capture_pdf for AI agents. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000 shots. It is not a replacement for Selenium when your test needs browser actions, application assertions, or end-to-end interaction.
Sign up free for 1,000 screenshots a month, with no card required.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Fix the driver behind crashes, sound loss and screen glitches3Repair Windows errors before they cause bigger problems
