Forem: Nithya Sen

Python Selenium Architecture and Virtual Environment Usage

Nithya Sen — Tue, 07 Apr 2026 03:55:05 +0000

Python Selenium Architecture

Python Selenium Architecture enables communication between automation scripts and modern web browsers. It consists of 4 primary layers.

1. Selenium Client Libraries / Language Bindings

These are the APIs (like the selenium package in Python) that allow you to write commands in Python. These bindings translate your code into a standardized format.

2. WebDriver Protocol

Selenium 4+ (Current): Uses the W3C WebDriver Protocol, which is the industry standard. This allows for direct, more stable communication with browsers.

3. Browser Drivers

These are browser-specific executables (e.g., chromedriver for Chrome, geckodriver for Firefox). They act as intermediaries that receive commands from the WebDriver API and execute them natively in the browser.

4. Web Browsers

The final layer where the actual automation occurs. The browser receives instructions from the driver, performs the actions (like clicking or typing), and sends the response back through the same chain.

How the Workflow Works

Script Execution: You run a Python script using commands like driver.get("url").
API Call: The Selenium Python library converts these commands into the W3C WebDriver Protocol format.
Driver Interaction: The command is sent to the specific Browser Driver via an HTTP request.
Browser Execution: The driver translates the request into native browser actions. The Browser executes the task and sends a status response (success or failure) back to the driver.
Result Return: The driver sends the result back to your Python script, which then proceeds to the next line of code.

A Python virtual environment is an isolated workspace that allows you to manage dependencies for different projects separately. Think of it as a dedicated "sandbox" for each project, ensuring that the libraries required for one don't interfere with those required for another.

1. Significance of Virtual Environments

Dependency Isolation

Different projects often require different versions of the same library. For instance, an older project might need Django 3.2, while a new one requires Django 5.0. A virtual environment allows both to coexist on the same machine without conflict.

Avoiding "System Pollution"

Installing packages globally (using pip install without an environment) can break system-level tools that rely on specific Python configurations. Virtual environments keep your global Python installation clean and stable.

Reproducibility

By using environments, you can generate a requirements.txt file that lists the exact versions of every library used. This ensures that any other developer (or a deployment server) can recreate the exact same setup.

Permission Management

Installing global packages often requires administrative or sudo privileges. Virtual environments allow you to install any package as a regular user within that specific folder.

2. Practical Examples

Example A: Version Conflict Resolution

Imagine you are working on two different data science projects:

Project	Required Library	Version
Project Alpha	Pandas	`1.5.0`
Project Beta	Pandas	`2.2.0`

Without a Virtual Environment:
If you upgrade Pandas to 2.2.0 for Project Beta, Project Alpha’s code might break because certain functions were deprecated or changed in the newer version.

With a Virtual Environment:
You create env_alpha and env_beta. Each project stays "locked" to its required version, allowing you to switch between them seamlessly.

Example B: Testing a New Library

Suppose you want to try a new web framework like FastAPI, but you aren't sure if you’ll keep it.

The Workflow: Create a temporary environment, install FastAPI, and experiment.
The Benefit: If you decide not to use it, you simply delete the environment folder. No stray files or unused libraries remain on your system.

3. How to Use It (Quick Commands)

To create and activate a virtual environment in Python, use the built-in venv module:

1. Create the environment:

python -m venv my_project_env

2. Activate it:

Windows: my_project_env\Scripts\activate
macOS/Linux: source my_project_env/bin/activate

3. Install a specific library:

pip install requests==2.28.1

Selenium Overview

Nithya Sen — Wed, 01 Apr 2026 04:01:10 +0000

What is Selenium?

Selenium is an automation tool widely used to perform browser automation. For example, consider we are working for Amazon and our task is to make sure the user is able to place an order successfully. Say this has to be done every day to make sure there is no breakage in the application due to everyday code deployment. Its tedious and time taking to verify this function manually every day. So here comes our Selenium tool using which we can place an order on Amazon and verify the order goes through, without any manual intervention. Once the test execution is done, we get to see the report if all the tests we coded are passed. This way one can avoid manual testing and any redundant tasks.

Selenium Titbits

Development: Selenium was developed in the year 2004 by a team in ThoughtWorks.
Original Name: It was initially called JavascriptTestRunner and was used to automate ThoughtWorks internal application ‘Time and Expenses’.
How Selenium got its name?: In 2004, the dominant commercial testing tool was made by a company called Mercury Interactive (later acquired by HP). While brainstorming a name for his new project, creator Jason Huggins joked in an email that "mercury poisoning can be cured by taking selenium supplements." The team loved it and the name stuck.
It is a W3C Standard: Selenium WebDriver became a World Wide Web Consortium (W3C) Recommendation in 2018. This is a massive deal because it means that browser vendors (like Google, Apple, and Microsoft) are now responsible for developing the drivers that allow Selenium to communicate with their browsers. This makes the automation much more stable and "native" than it used to be.
The "Remote Control" Hack: In the early days, browsers had a security feature called the Same-Origin Policy, which blocked JavaScript from interacting with a site if the script didn't come from that exact same domain. To "trick" the browser, Paul Hammant created Selenium RC (Remote Control). It acted as a HTTP proxy, making the browser believe that the Selenium Core (JavaScript) and the website being tested were from the same source. It was a clever, slightly messy workaround that paved the way for modern automation.
Google’s Massive Role: While it started at ThoughtWorks, Selenium’s "teenage years" were spent at Google. Jason Huggins joined Google in 2007, and for a long time, Google was the primary driver of the project. They needed a way to test their massive applications (like Gmail and Maps) across every possible browser, so they poured resources into making Selenium scalable.

Why do we use Selenium for Automation?

Selenium supports browser automation which helps in automating testing all manual test execution for any sort of web application.
Selenium is an open source software and has huge developer and community support.
It supports wide range of programming languages like Java, Javascript, C#, Python, and Ruby.
A single Selenium script can be executed across different environments. This "write once, run anywhere" capability is vital for Cross-Browser Testing.
- Browsers: Chrome, Firefox, Safari, Edge, and Opera.
- Operating Systems: Windows, macOS, and Linux.
Support for Parallel Execution: With Selenium Grid, we can run multiple tests simultaneously across different browsers and operating systems.
It integrates seamlessly with:
- Build Tools: Maven, Gradle, Ant.
- CI/CD Tools: Jenkins, Azure DevOps, GitLab.
- Testing Frameworks: JUnit, TestNG, PyTest.

What is the relevance of Selenium in Automation Testing using Python?

The pairing of Selenium and Python is one of the most popular combinations in the world of Quality Assurance.

Readability: Python allows testers to write scripts that are easy to understand for everyone on the team as its close to plain English
Powerful Library Ecosystem: Python has a large library of "packages" that integrate perfectly with Selenium:
- PyTest: The industry-standard framework for organizing and running tests.
- Pandas: For Data-Driven Testing (reading thousands of test cases from CSV/Excel).
- Behave: For Behavior-Driven Development (BDD), allowing you to write tests in "Given/When/Then" format.
Since Python is the leading language for AI and Machine Learning, using Selenium with Python makes it much easier to integrate AI models that can "heal" broken tests or analyze UI screenshots for visual bugs.

Common Manual Testing Techniques

Nithya Sen — Sun, 01 Feb 2026 09:59:03 +0000

What is Manual Testing?

Manual Testing is the process in which a software is tested to make sure it functions as intended.

Below are some common Manual Testing Techniques:

Exploratory Testing:

What is it?: Exploratory testing is done by exploring the app like an end user would do.

When do we use?: We use Exploratory Testing in the following cases:

When we have short period of time and have no enough time to write test cases, we use exploratory testing.
When we want to test the app like an end user would do, without knowing what the Functional Requirement Document says, we use exploratory testing. This way we explore the app and cover all scenarios an end user would encounter

How do we do?: We explore the application and note down any discrepancies/errors we see. We also note down all the scenarios we tested and make Exploratory Testing notes which we can deliver to the client, so one would know what exactly been tested and what sort of bugs have been discovered.

Experience Based Testing:

What is it?: Like the name suggests, Experience Based Testing is done based on one's own experience of the app or the domain. Its

When do we use?: We use Experience Based Testing in the following scenarios

If we don't have Requirement document, we follow experience based testing, to uncover bugs and to ensure the app works well
If we don't have enough time and needed to uncover all critical bugs
In early stage startups where the requirement is not stable, we use experience based testing

How do we do?: 'Error Guessing' is the common technique of Experience Based Testing. As an experienced tester, the tester would know where more bugs would occur and where the app might break. This way, its easy for the tester to uncover all the bugs from their past experience of the app, skill and intuition.

Blackbox Testing:

What is it?: Blackbox Testing is about testing the functionality of the app without knowing about how the application is built underneath.

When do we use?: Once the application is built, we do the blackbox testing by executing test cases and uncover any bugs.

How do we do?: First, we prepare test cases based on the Requirement Document. We will also have Requirement Traceability Matrix prepared to make sure all the requirements are covered in the test cases. Once the test cases are ready, we will execute them and make sure they all pass. In the case failure, we log bug and report to development team and all stakeholders.

Test case Design Technique:
In Blackbox Testing, we have the following major Test Case Design Technique.

**Equivalence Partitioning: **In Equivalence Partitioning, we divide the test data into equal parts and choose one data from each partition and test. This is useful when we have large number of data to test. For example: If we need to test age, we can partition it into 3 categories: Negative values, 0 to 18 and above 18. This way, we don't have to cover all possible values since its impossible and unnecessary.

Why Equivalence Partitioning:

We avoid redundancy by choosing only one number from a particular group
We make it efficient by only testing what would confirm the result
This also provides better coverage by testing for both valid and invalid data

Boundary Value Analysis:
In this technique, we check for errors at the boundary. For example, if only users above the age of 13 is allowed to create an account, then testers can derive test cases with values 12,13 and 14. Checking the boundary of a valid input ensures thorough testing and functions as most of the time there is likely to be an error at the edges of a valid input.

Decision Table Testing:

What is it? We use Decision Table for complex systems that has different outcomes for different combination of inputs
For example:

Conditions         Rule 1   Rule 2  Rule 3  Rule 4
Is New User?             Y    Y   N   N
Has Coupon?          Y    N   Y   N
Actions             
Apply 20% Discount   ✔            
Apply 10% Discount            ✔   
No Discount           ✔             ✔

How to Read this?
Rule1: If the user is New and has coupon, apply 20% discount
Rule2: If the user is New but has no coupon, apply no discount
Rule3: If the user is not new but has coupon, apply 10% discount
Rule4: If the user is not new and has no coupon, no discount

With the decision table, its easy to read and test complex rules and scenarios.

State Transition Testing:
We use this technique when the application involves going through several different states based on the previous actions and states.

For example: During ATM Pin validation, we display the choices based on the apps current state. If the current state is a welcome screen and if the user has entered right pin, then the application will show the next state which are options the user can carry out. If the user has entered a wrong pin, then it would show First-attempt failed screen. Below is the detailed state of each stage:

Current state            Event                    Next state           

Welcome screen         Enters right pin          Dashboard is shown

Welcome screen         Enters incorrect pin      First Attempt Failed

First Attempt Failed   Enters incorrect pin      Second AttemptFailed

Second Attempt Failed  Enters incorrect pin      Account Locked

Second Attempt Failed  Enters correct pin        Dashboard is shown

With state transitions clearly described, we can catch all the issues and also make sure it works in all the scenarios.

Use-case Testing:

In Use-case Testing, we start testing by writing use-cases from the requirement document. In this, we perform end-to-end testing, where we test from the beginning till the end of the flow uncovering any integration bugs or design defects.

Testers start by listing out all the posible usecases that an end-user might perform.

Benefits of use-case testing is that, it reduces the complexity of the system as the path of testing will be derived in the use-case document. Testing from the user's perspective is another good benefit to discover any bugs that lies in the typical path.

Some Drawbacks are that: As they are user-focused, some edge cases can be missed and 100% of the scenarios cannot be tested. Other thing is that it covers only functional part of the requirement. Aspects like performance and security cannot be covered.

Monkey Testing:

As the name suggests, in monkey testing, the tester would click random buttons, visits random pages, does random actions deliberately like a monkey would do in an aim to assert the application's stability and error handling capacity.

This would be helpful to discover some nasty workflows that would break the system. Its not possible to find these kind of bugs in a normal functional testing where focus is to ensure that the function works.

Monkey testing is necessary to make sure that the app works well even in any unpredicted steps that a user might carry out.

Future of Manual Testing in the Age of AI

In the age of AI, performing manual testing is made simple. Because we can use AI and write test cases in minutes. We can also take AI's help in thinking out all the possible scenarios including all sort of edge cases. Tester's efficiency is increased with the help of AI tools.

Following are some of the common AI tools we can use to write test cases in seconds:

ChatGPT
Google Gemini
Claude

Though AI can analyse requirement, come up with test cases, implement them and run them, there are certain limitation. They are:

They can't perform Exploratory Testing like an end user would do
They can't do usability testing like a human would do
They can't perform any testing that requires human intuition
Though it generates Test cases, we may still require some manual editing as all of our instructions are not always followed no matter how good our prompts are. They are still in evolutional stage.

Verdict: Use AI but always double check how the actions are performed or created by AI as they are well prone to errors.