Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Selenium’s official documentation discourages eight kinds of browser-automation work, not a list of 24. The 24 examples below unpack those eight categories into practical cases where Selenium is usually the wrong tool—not a universal ban. Use a lower-level check, a controlled test setup, or manual testing when it answers the question more reliably.
How to use this checklist
Selenium’s test-practice guidance is contextual: the right choice depends on the test environment and what you need to prove. Its Discouraged behaviors page lists eight categories. The 24 items here are editorial examples grouped under those categories; Selenium does not publish a 24-scenario list.
As an Amazon Associate I earn from qualifying purchases.
For each case, ask whether a real browser interaction is essential. Browser-level functional tests cost more to run and require supporting infrastructure than unit or lower-level checks. Selenium’s Overview of Test Automation puts the principle plainly: “It is not always advantageous to automate test cases.”
Recommended Free Tools
CAPTCHA challenges
Selenium discourages CAPTCHA automation. A browser test should not become an attempt to defeat an anti-automation challenge.
#1 Best Overall
- Solving a CAPTCHA to create a test account. Use a test-environment approach agreed with the product and security teams if account creation needs coverage.
- Retrying CAPTCHA challenges until one passes. Repeated attempts test the challenge’s defenses and can make the suite unreliable, rather than establishing that the application flow works.
- Automating CAPTCHA completion in a critical user journey. Keep the application-flow test focused on the behavior your team controls; do not build it around defeating a protective check.
File downloads
Selenium lists file downloads as discouraged browser-automation work. A browser may trigger a download, but it is often not the best place to verify the generated file or delivery behavior.
- Checking that a report contains the right data. Validate the report-generation logic or file contents through a more direct interface where possible.
- Verifying a file’s format or metadata. Test the produced file directly instead of relying on browser download handling to establish its properties.
- Checking that an export endpoint returns the expected file. Use an appropriate direct application or HTTP-level check if the requirement is the returned file itself; reserve browser automation for a user interaction that genuinely needs a browser.
HTTP response codes
Selenium discourages using browser automation to check HTTP response codes. A browser workflow is not the most direct evidence for a transport-level status.
- Checking whether an API returns a particular status. Make an HTTP-level test for the API response rather than infer it from what a browser displays.
- Confirming that a page endpoint returns an error status. Request the endpoint directly in a test suited to verifying its status code.
- Auditing status codes across many URLs. This is not a user workflow; check responses with a method built around HTTP requests instead of driving a browser for each link.
Gmail, email, and Facebook logins
Selenium’s discouraged list names Gmail, email, and Facebook logins. Tests of your application should not depend unnecessarily on a live third-party login flow that can change independently.
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →- Signing into Gmail to retrieve a verification message. Avoid making a browser test depend on an external mailbox’s live login interface; test your application’s email-related behavior through a controlled setup.
- Logging into a live email provider to prove your app’s login works. Keep the test focused on the app’s own authentication flow rather than the provider’s changing pages and policies.
- Automating Facebook login as a prerequisite for an app test. If the app’s integration is in scope, isolate the behavior you control and avoid relying on a third party’s live login flow for every test run.
Dependent tests
Selenium discourages test dependencies and encourages independent tests. A test should not require an earlier test to pass or leave behind state.
- Test B can run only after Test A creates an account. Give Test B its own setup so it can run alone and reveal its own failure.
- A checkout test relies on a cart left by another test. Create or prepare the cart within the test’s own controlled setup rather than depending on execution order.
- A test assumes another test has already changed shared data. Make the required state explicit and independent; shared, order-sensitive state makes failures harder to diagnose.
Performance testing
Selenium lists performance testing as discouraged. Browser automation is meant to exercise user-facing behavior, not serve as the primary way to measure system load or response performance.
- Measuring server response time by timing a browser click. Browser rendering and other client-side work can affect the observation; use a performance-focused measurement suited to the question.
- Generating load by launching many Selenium sessions. Do not treat end-user browser automation as your main load-generation method.
- Using a long UI journey as a performance benchmark. A multi-step browser flow is difficult to interpret as a measure of system performance; separate performance questions from functional browser checks.
Link spidering
Selenium discourages link spidering. Crawling a site to inventory links is a different job from verifying a user-critical browser workflow.
- Opening every link on every page to build a site-wide inventory. Use a crawling or link-checking approach rather than turning a browser test suite into a general-purpose spider.
- Following every internal link to find broken destinations. Check links directly where possible; keep Selenium focused on the links and transitions central to a defined user task.
- Recursively crawling an entire site from one browser test. A single sprawling crawl is difficult to diagnose and does not establish a specific user behavior. Define discrete browser checks for important journeys instead.
Two-factor authentication
Selenium lists two-factor authentication (2FA) as discouraged. A live second-factor challenge or message delivery can make an end-to-end browser test fragile. If your application’s authentication behavior needs coverage, work with security stakeholders on a controlled test setup; do not weaken protections in production.
- Waiting for a live SMS code during every test run. Delivery delays and external messaging behavior can derail the test without revealing whether the application’s own flow is correct.
- Opening a live authenticator app to read a rotating code. Avoid making a routine browser check depend on manually or indirectly accessing a live second factor.
- Requiring a live email one-time code to complete every browser test. Test the application’s relevant authentication behavior through a controlled approach designed with security stakeholders, not by relying on live delivery for each run.
When Selenium is still the right choice
These examples are reasons to choose the test level carefully, not reasons to avoid Selenium altogether. Use it when the requirement depends on real browser interaction—such as proving that a user can complete a specific, important interface flow—and a lower-level test cannot establish the same behavior.
Best Value
- Prefer a unit or lower-level test when it can prove the required application logic without a browser.
- Keep a browser test short with one discrete action and evaluation. Selenium’s documentation warns that long workflows take longer, risk rendering-timing problems, and make failures harder to diagnose. Its example of creating an account, configuring an item, checking out, paying, and leaving feedback is better split into smaller, speedy tests, each with one reason to exist. See Encouraged behaviors for its related guidance on test independence.
- Consider manual testing for a short-term need when the interface is changing substantially or there is not enough time to build automation before a pressing test deadline. That is a trade-off, not a claim that manual testing is always preferable.
Choosing the right test approach
Before automating a scenario, compare the options against the actual requirement:
| Question | Selenium browser test | Unit or lower-level test | Manual test |
|---|---|---|---|
| Does the requirement depend on real browser interaction? | Fits when browser behavior is essential. | Fits when the relevant behavior can be established below the browser layer. | Can cover an interface task when a short-term hands-on check is more practical. |
| What is the execution and infrastructure cost? | Relatively costly to run and needs supporting infrastructure. | Often a lighter option when it answers the same question. | Requires a person to perform the check rather than automated browser infrastructure. |
| How exposed is the check to UI or external-service changes? | A browser workflow can be affected by interface timing or third-party login changes. | Can avoid UI dependencies when testing logic below that layer. | May be practical while an interface is changing substantially. |
| How easy is it to diagnose a failure? | Short, independent tests are easier to diagnose than a long workflow. | Use when the lower-level test clearly identifies the behavior under test. | A tester can investigate directly, but the check is not automated. |
| Is there enough time to build and maintain automation? | Build when the value of repeatable browser coverage justifies the setup and upkeep. | May be the lighter answer when browser coverage is unnecessary. | Can be a reasonable short-term choice when a deadline is near or the interface is changing considerably. |
The table is a practical decision aid, not a formal Selenium scoring framework. The Selenium project’s official pages describe recommendations as guidelines, and they were last modified September 16, 2026; their advice may change as the documentation is updated.
Or skip the browser setup
If your requirement is to capture a clean page image rather than test browser behavior, ScreenshotNeo is a website screenshot API and MCP server from Yorker Media. A single GET request can return a PNG, JPEG, WebP, or PDF. For example:
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Clear out junk files and repair common Windows errors3Scan for outdated or missing drivers - takes under a minuteQuick Recap
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpSee the ScreenshotNeo documentation for API options. Cookie banners, popups, and chat widgets are removed before the shot; bot checks, blank pages, and failed loads are never billed. Its MCP server lets AI agents take screenshots. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000. Sign up for free.
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.
