DEV Community: Madhesh

Selenium Architecture & Setup

Madhesh — Mon, 14 Sep 2026 11:59:56 +0000

Inside Selenium: Understanding its Architecture and the Importance of Virtual Environments in Python

There was a time when I had been using Selenium without understanding at all how Python lines would result in movement of the actual Chrome window. Once the trainer explained the architecture to us, a lot of the peculiar errors which I kept facing became clear to me. This is what I understood along with another lesson that took me an entire afternoon to learn.

Selenium architecture, level by level

WebDriver is a Selenium module consisting of four components that act in sequence.

The client library is the module I install via pip. This is the language binding provided for Python, Java, C#, JavaScript, and Ruby. When I call driver.find_element(By.ID, "user"), the language binding does not interact with the browser in any way. It converts my method call into a regular HTTP request, consisting of URL and JSON payload.

This is what the protocol transports. Here lies the difference between Selenium 3 and Selenium 4. Selenium 3 uses the JSON Wire Protocol, which means that the request needs to be translated from the client side and then decoded by the driver because each browser speaks its own dialect. Selenium 4 supports the W3C WebDriver standard, implemented natively by all major browser vendors. There is no longer a need for any kind of translation layer, and this is one of the reasons why Selenium 4 tests are more robust.

The browser driver is the executable like ChromeDriver, GeckoDriver, or EdgeDriver. Not only is this something we install and ignore. Every driver has its own little HTTP server listening on a local port, receiving my request and translating it into commands for the browser engine. This is also the reason why I cannot use Chrome 130 and ChromeDriver from long ago. The driver speaks only to one browser version.

The browser executes the action and the result gets translated back through HTTP just like in any other case, to become a Python object like WebElement or boolean.

Selenium Grid extends the same idea to other machines. Selenium 4 splits the Grid into a router, a distributor, a session map and nodes, making it possible for my laptop to control a Firefox session in a totally different machine with the exact same code.

The importance of virtual environments

My very first error in Python was to install all packages globally. For example, the first project required an older version of Selenium, and the second one requires the most recent, but just one command pip install silently destroyed the first project.

Virtual environments help avoid such problems since they create an isolated folder with an isolated Python interpreter and site-packages. None of the installed packages will leak out.

For instance, my practice project works with Selenium 4.21 and pytest 8, and an older course project requires Selenium 3.141, since it uses find_element_by_id. Two different environments, two folders, no conflicts. Another example would be reporting. One project needs pytest-html, and another one needs Allure.

The process is simple: python -m venv venv, activate it, pip install selenium pytest, and finally pip freeze > requirements.txt. With that file, a colleague or a CI pipeline can recreate the environment with just one command. This is how test results become reproducible, instead of saying “it works on my machine”.

Getting an insight into both concepts influenced my debugging approach because I understood at which level the failure occurred and that my dependencies were not to blame.

Introduction to selenium

Madhesh — Mon, 14 Sep 2026 11:57:55 +0000

What Selenium Tells Us About Automation Testing Using Python

From the very beginning of the course, the first testing automation tool introduced to us was Selenium. I expected to encounter a simple playback application but was surprised to find out that there is a library which allows controlling the real browser programmatically.
**
What is Selenium?**

Selenium is a free and open-source suite of tools designed to automate web browsers. Instead of the tester performing all the actions manually in Chrome such as going to a URL, logging in, etc., we write the script that does those actions on behalf of the tester.

The main component of Selenium is Selenium WebDriver. The tool we use daily is Selenium WebDriver, which interacts with browsers through their drivers (for example, ChromeDriver for Chrome, GeckoDriver for Firefox). In addition, there is Selenium IDE which is a plugin for browsers that allows recording the actions and there is Selenium Grid, a functionality of Selenium that runs the tests in parallel on multiple machines/browsers.

What is important to mention here is that it is a real web session that is being automated. The web pages are loaded, JavaScript is being executed, web page elements are functioning properly and the whole action performed by the script is like a real person performing the given action on the web.

Why do we use it for automation?

Manual regression testing is tedious and costly. Every time there is a new release, one must verify if login functionality still works, if the basket calculates taxes properly, and if search functionality provides results. Doing all of this manually for the fiftieth time is bound to introduce errors since human attention wavers way sooner than the list finishes.

Selenium eliminates this problem. A test suite that takes two days to execute manually completes in less than an hour and runs during the night or after every code change. It runs in Chrome, Firefox, Edge, and Safari browsers, making cross-browser testing almost cost-free. It is compatible with Java, Python, C#, JavaScript, and Ruby languages, meaning that it can be used by a team without switching programming languages. Being open-source, Selenium is free of charge, and there is a huge community who already figured out how to resolve common beginners' issues.

Its application in Python:

Selenium works best with Python. It uses compact syntax, so the code is easy to understand. driver.find_element(By.ID, "username").send_keys("admin") almost speaks for itself. For me as a learner, this translates to focusing on the actual Selenium concepts and not getting bogged down by syntax.

Ecosystem wins anyway because pytest adds fixtures, parametrization, markers and reporting that lets me test my case against ten different sets of data without writing any new code lines. pytest-html provides a report which can be shared with a reviewer. The POM design pattern lets me keep all locators in a single class, and when something has to be changed, I just have to change it once in this file. Adding API validations via requests, data-driven tests with pandas and Allure as a reporting tool makes this script evolve into a complete framework.

Selenium is not perfect because it can work only with web applications, test cases fall apart if the interface is changed and waits drive crazy people when they first encounter them. Still, it is a base of almost any automation career path, and working with Selenium using Python gives me a much better understanding of the process than any theoretical chapter ever could do.

Manual testing and its Techniques

Madhesh — Sun, 26 Oct 2025 13:09:10 +0000

Introduction for manual testing:

Manual testing is the phase which comes under software development which ensures the delivery of the developed software product is reliable and functional with high quality without any compromise .The manual testing consists of several phases in which each part of the product will tested whether it is working fine as expected this contains testing both positive and negative scenarios where we can identify what is working and what is not working also we can make sure about the design flaws and logical inconsistencies without testing a product cannot be launched or used by the end user thus manual testing is must in the software development life cycle. This can be done by identifying the possible test scenarios based on positive and negative flows and drafting the testcases and executing them with the help of test data usually happens in testing environment.

1.Common Manual testing techniques:

The manual testing techniques contains different types the below are the techniques which are widely used among the industries by current software development companies

• White box testing: This testing methodology consists of process which test the developed code in a deep level internally such as structure, mappings, designs, connections etc..

• Black box testing: This testing methodology consists of process which test the functionality from the end user perspective Ex: making sure whether the login functionality is working fine in the portal

• Grey box testing: The process of testing a software product by combining both understanding the internal logics and functionality with an overall understanding mostly this will be done by subject matter expert in QA testing.

• Smoke testing: This testing will be performed when a new build is deployed in a existing product to make sure no exiting code is broken.

• Integration testing: This process consists of testing the connections between systems like API and databases once connected to make sure the data flow.

• Regression testing: This testing is like just doing a high-level testing for all the components if any fix or code changed has been made mostly regression suit will be prepared and tested.

• Acceptance testing: It ensures whether the software met its requirements and rules as per the user expectations testers will draft scenarios based on this

2.Boundary Value analysis (BVA):

The boundary value analysis is the testing methodology which comes under black box testing the tester will test first understand the input parameters and ranges of the functionality for example if there is registration page it will contain two columns username and password there must be some range conditions in which username must be within 4-15 so the tester will test the boundary values the possible test cases will be like test by entering 4 letter and 15 letters and less than 4 and more than 15 this method of testing the boundaries of the parameter with respect to the business logic already implemented is called as boundary value analysis.

Advantage:

• The tester only needs to test specific scenarios as per business logic don’t need to test all the positive scenarios to ensure the functionality

• This will make sure whether the entering the input parameters doesn’t breaching the business logic example: if the password creation contains some format and limit by BVA we can ensure it accomplish the business logic which was implemented in back end code.

3. Decision table testing:

This methodology is also a black box testing methodology where it is used to test the complex business rules and logics in this process the tester will test the all the possibilities as per the business logic which needs to ensured and implemented in the code wise. This can be implemented by understanding the actions and business rules and creating a table which contains of different possible possibilities such as positive and negative scenarios in order to accomplish all the possible decision which the system will react with respect to the functionality.
Example: For a banking application where:
Condition 1: If Account balance > ₹10,000
Condition 2: If Customer has no loan dues

Rule Condition-1 Condition-2 Action
1 True True Approve Loan
2 True False Reject Loan
3 False True Reject Loan
4 False False Reject Loan

Like the above table the tester will setup the test data and test the possible scenarios with respect to the decision table.

This table ensures all possible input combinations are tested, preventing logical errors in decision – making.

4. The future of Manual testing in the Age of AI:
We know that AI is emerging in all the fields right now as per the world order thus the software development also have a major part in AI revolution in which it consists of software testing life cycle also int it. The AI and automation reshape the manual testing by the help of AI powered tools with respect to automation flow where human testers focus on the cognitive and exploratory testing most of the AI tools which used in the software testing are designed to automate the testing process which can ensure the quality at the same time with less effort and time thus nowadays AI tools plays a major role in software testing.

Critical factors:

• However, AI tools will reduce time and effort but it cannot provide 100 % quality since Human sense of testing a products usability with respect to the end user cannot be accomplished completely by any AI tools the tester can provide possible static and dynamic scenarios to AI tools but a product which will have human as END user cannot be completely testable with AI or Automation.

• AI can assist tester more possible positive and negative scenarios and suggest more test cases which will be helpful to ensure the quality but not upto the mark.

• In order to adopt the AI tools and automation the tester must also be up to date and upskilling is the essential part for manual testers to stay relevant in the software testing market across the globe.

Conclusion:

Therefore, manual testing remains an irreplaceable component of software quality assurance despite the automation testing or AI advancements. Techniques like Boundary value analysis, and decision table testing, grey box testing helps to ensure the software product by 99.99 % percentage the rest 0.01 % will also be covered by executing the performance and load testing which will be determined by the third-party services such as internet, servers and other factors.

Done by: Madheshwaran V