Short answer: Fresher QA interviews generally cover four areas: testing fundamentals such as SDLC, STLC, testing levels and testing types; test design techniques such as test cases, boundary value analysis and equivalence partitioning; defect management and the defect life cycle; and automation fundamentals using tools such as Selenium, Playwright or a language-based testing framework.
Manual testing remains an important foundation for entry-level QA roles, but modern QA roles increasingly combine manual testing with automation, API testing, SQL, Git and CI/CD.
For a fresher, knowing definitions alone is not enough. You should be able to write test cases, identify edge cases, report defects, explain automation concepts, test APIs and validate database data.
A good QA candidate does not only ask:
“Does the feature work?”
They also ask:
“What happens with invalid input, boundary values, unexpected actions, network failures, duplicate requests or incorrect data?”
That mindset is central to software testing.
Manual vs Automation Testing
Manual and automation testing serve different purposes. Most professional QA teams use both.
| Factor | Manual Testing | Automation Testing |
|---|---|---|
| Who executes | Human tester | Automation scripts |
| Best for | Exploratory, usability, ad-hoc and one-off testing | Regression, repetitive and data-driven testing |
| Speed | Slower for repeated execution | Fast after scripts are created |
| Upfront cost | Lower | Higher |
| Maintenance | Human effort required for every execution | Scripts need maintenance when application changes |
| Accuracy | Human judgement is valuable, but repetitive tasks can cause errors | Consistent execution within defined scenarios |
| Skills | Test design and domain knowledge | Programming and framework knowledge |
| Common tools | JIRA, TestRail | Selenium, Playwright, TestNG, JUnit, PyTest |
| API testing | Often manual with Postman | REST Assured, Playwright and other automation tools |
| Regression | Time-consuming manually | Highly suitable for automation |
When should you use manual testing?
Manual testing is particularly useful for:
- Exploratory testing
- Usability testing
- New features
- One-time scenarios
- Visual inspection
- Ad-hoc testing
- Scenarios requiring human judgement
For example, a tester can notice that a checkout button is confusing, an error message is unclear or a mobile layout feels difficult to use.
When should you use automation?
Automation works well for:
- Stable functionality
- Regression testing
- Repetitive scenarios
- Data-driven tests
- Cross-browser testing
- API regression
- Frequently executed business-critical workflows
For example, login, checkout and core API regression tests are often good automation candidates.
A strong interview answer is:
“I would automate stable and repetitive scenarios that run frequently, while using manual testing for exploratory, usability and scenarios that require human judgement.”
Manual Testing Interview Questions (1–20)
1. What is software testing?
Software testing is the process of evaluating software to determine whether it meets specified requirements and identifying defects or unexpected behaviour.
Testing can cover:
- Functionality
- Performance
- Security
- Usability
- Compatibility
- Reliability
- Accessibility
- Data integrity
For example, testing a login page should include more than valid credentials.
You should also test:
- Valid username and valid password
- Invalid username
- Invalid password
- Empty fields
- Invalid email format
- Account lockout
- Session timeout
- Password masking
2. What is verification vs validation?
Verification asks:
“Are we building the product right?”
It generally involves reviews and inspections of work products.
Examples include:
- Requirement reviews
- Design reviews
- Code reviews
- Walkthroughs
Validation asks:
“Are we building the right product?”
It involves evaluating the actual software.
Examples include:
- Functional testing
- System testing
- User acceptance testing
| Verification | Validation |
|---|---|
| Reviews work products | Tests actual software |
| Often does not require execution | Requires software evaluation |
| Checks development artefacts | Checks product behaviour |
3. What is the STLC?
STLC stands for Software Testing Life Cycle.
A commonly used flow is:
Requirement Analysis
↓
Test Planning
↓
Test Case Design
↓
Environment Setup
↓
Test Execution
↓
Test Closure
During requirement analysis, testers understand what needs to be tested.
During test planning, the team defines scope, resources, schedule, tools and risks.
During test design, test cases and test data are prepared.
During execution, tests are run and defects are reported.
Test closure involves evaluating testing results, defect status and lessons learned.
4. What are the levels of testing?
The four commonly discussed levels are:
- Unit testing
- Integration testing
- System testing
- Acceptance testing
Unit testing tests individual functions or components.
Integration testing tests interactions between components.
System testing evaluates the complete integrated application.
Acceptance testing determines whether the system meets business or user requirements.
For example, in an e-commerce application:
Unit → Calculate discount
Integration → Cart + payment
System → Complete checkout
Acceptance → Business approves checkout workflow
5. Functional vs non-functional testing?
Functional testing checks what the system does.
Examples:
- Login
- Registration
- Search
- Checkout
- Payment
- File upload
Non-functional testing checks how well the system behaves.
Examples:
- Performance
- Security
- Usability
- Compatibility
- Reliability
- Scalability
- Accessibility
For example:
“The user can upload a file” is functional.
“The file should upload within an acceptable response time” is non-functional.
6. Smoke vs sanity testing?
Smoke testing checks whether a new build is stable enough for detailed testing.
A smoke suite for an e-commerce application may verify:
- Application opens
- Login works
- Search works
- Product page opens
- Cart works
- Checkout opens
Sanity testing is more focused and typically checks whether a particular change or fix works.
For example, after a coupon bug is fixed, sanity testing may focus on:
- Valid coupon
- Invalid coupon
- Expired coupon
- Coupon removal
- Discount calculation
| Smoke | Sanity |
|---|---|
| Broad and shallow | Narrow and focused |
| Checks build stability | Checks specific changes |
| Often run on new builds | Often follows fixes or small changes |
7. What is regression testing?
Regression testing verifies that existing functionality has not been broken by new changes.
Suppose developers modify the payment module.
You may need to retest:
- Cart
- Checkout
- Payment
- Order creation
- Confirmation
- Email notification
because the payment change may affect related functionality.
Automation is particularly useful for regression because the same suite can be executed repeatedly.
8. What is retesting?
Retesting means testing a failed scenario again after the defect has been fixed.
Example:
Test login
↓
Failed
↓
Defect reported
↓
Developer fixes defect
↓
Tester executes same test
↓
Passed
Retesting focuses on the specific defect.
Regression testing checks whether the change caused problems elsewhere.
Remember:
Retesting asks, “Did the fix work?”
Regression asks, “Did the change break anything else?”
9. Black box vs white box testing?
Black box testing evaluates behaviour without requiring knowledge of the internal code.
The tester focuses on:
Input → System → Output
White box testing considers internal code and logic.
It can involve:
- Code paths
- Branches
- Conditions
- Statements
- Loops
Developers commonly perform significant amounts of white-box testing through unit tests.
10. What is boundary value analysis?
Boundary Value Analysis, or BVA, focuses on values at the edges of accepted ranges.
Suppose an age field accepts 18 to 60.
Instead of testing only:
25
35
45
test:
17
18
19
59
60
61
Many defects occur around boundaries.
For example:
if (age > 18)
behaves differently from:
if (age >= 18)
BVA helps expose such errors.
11. What is equivalence partitioning?
Equivalence Partitioning divides inputs into groups expected to behave similarly.
For an age field accepting 18 to 60:
Below 18 → Invalid
18–60 → Valid
Above 60 → Invalid
Instead of testing every possible age, you can test representatives:
17 → Invalid
30 → Valid
61 → Invalid
BVA and equivalence partitioning are often used together.
12. What is a test case? What fields does it have?
A test case is a documented set of conditions, steps and expected results used to verify a specific behaviour.
Typical fields include:
| Field | Purpose |
|---|---|
| Test Case ID | Unique identifier |
| Title | What is tested |
| Preconditions | Required starting conditions |
| Test data | Input values |
| Steps | Actions |
| Expected result | Expected behaviour |
| Actual result | Observed behaviour |
| Status | Pass/Fail/Blocked |
| Priority | Business importance |
Example:
Title: Login with valid credentials
Precondition: Registered user exists.
Steps:
- Open login page.
- Enter valid username.
- Enter valid password.
- Click Login.
Expected result: User is redirected to the dashboard.
13. Test plan vs test strategy?
A test strategy defines the high-level testing approach.
It may cover:
- Testing objectives
- Testing levels
- Test types
- Tools
- Automation approach
- Risks
A test plan describes how testing will be performed for a particular project or release.
It can include:
- Scope
- Schedule
- Resources
- Environment
- Responsibilities
- Entry and exit criteria
- Deliverables
In simple terms:
Strategy defines the overall approach; the test plan defines the execution details for a particular testing effort.
14. Explain the defect life cycle.
A simplified defect life cycle is:
New
↓
Assigned
↓
Open
↓
Fixed
↓
Retest
↓
Closed
Other possible states include:
- Rejected
- Duplicate
- Deferred
- Reopened
For example:
New
↓
Developer assigned
↓
Fixed
↓
Retest
├── Pass → Closed
└── Fail → Reopened
The exact workflow varies by organisation and defect-management tool.
15. Severity vs priority?
Severity describes the impact of the defect.
Priority describes how urgently it should be fixed.
For example, a spelling mistake in a company’s name on the homepage could be:
Severity: Low
Priority: High
if the page is being used for a major public launch.
A serious defect in a rarely used internal feature could potentially have:
Severity: High
Priority: Medium
The classification depends on business context.
Remember:
Severity = impact.
Priority = urgency.
16. What is exploratory testing?
Exploratory testing involves learning about the product, designing tests and executing them simultaneously.
Instead of following only predefined cases, the tester investigates the application and follows interesting findings.
For example, while testing registration, you notice that an unusual email format is accepted.
You investigate:
Unusual email
↓
Invalid domain
↓
Duplicate account
↓
Password reset
Exploratory testing relies heavily on:
- Curiosity
- Experience
- Observation
- Risk awareness
- Domain knowledge
It is especially useful for new features.
17. What is UAT?
UAT stands for User Acceptance Testing.
It verifies whether the software meets business and user requirements before release.
UAT may involve:
- Business users
- Customers
- Product owners
- Client representatives
- Domain experts
QA may verify that a payroll system calculates salaries correctly.
Business users may then verify that the overall payroll process matches real company requirements.
18. Alpha vs beta testing?
Alpha testing generally happens earlier in a controlled environment, often internally.
Beta testing involves a limited group of external or real users in more realistic environments.
| Alpha | Beta |
|---|---|
| Earlier stage | Later pre-release stage |
| Controlled environment | Real-world environment |
| Often internal | Often external users |
| More controlled feedback | More realistic feedback |
19. What is an RTM?
RTM stands for Requirement Traceability Matrix.
It maps requirements to test cases.
Example:
| Requirement | Test cases | Status |
|---|---|---|
| Login | TC-001, TC-002 | Passed |
| Password reset | TC-003, TC-004 | Passed |
| Account lockout | TC-005 | Failed |
RTM helps determine whether all requirements have corresponding test coverage.
20. Write test cases for a login page.
A strong answer should cover several categories.
Positive
- Valid username and password
- Remember Me
- Login after password reset
Negative
- Invalid username
- Invalid password
- Empty fields
- Invalid email format
- Very long input
- Unsupported characters
Security
- SQL injection attempt
- Repeated failed logins
- Account lockout
- Password masking
- Session timeout
UI
- Login button
- Error messages
- Tab order
- Password visibility
- Responsive layout
A good tester thinks beyond the happy path.
Automation Testing Interview Questions (21–35)
21. What is Selenium, and what are its components?
Selenium is an open-source browser automation framework.
The main components to remember are:
WebDriver → Browser automation
IDE → Record/playback
Grid → Remote and parallel execution
A basic Java Selenium interaction might look like:
driver.get("https://example.com");
driver.findElement(By.id("email"))
.sendKeys("user@example.com");
driver.findElement(By.id("login"))
.click();
22. What locators does Selenium support?
Common Selenium locator strategies include:
- ID
- Name
- Class name
- Tag name
- Link text
- Partial link text
- CSS selector
- XPath
Example:
driver.findElement(By.id("username"));
CSS:
driver.findElement(
By.cssSelector("#username")
);
XPath:
driver.findElement(
By.xpath("//input[@id='username']")
);
The best locator is generally one that is stable, unique and readable.
If an application provides a stable test attribute such as data-testid, that can be preferable to a fragile DOM path.
23. Absolute vs relative XPath?
Absolute XPath starts at the root:
/html/body/div[2]/form/input[1]
It is fragile because DOM changes can break it.
Relative XPath focuses on a relevant element:
//input[@id='email']
or:
//button[text()='Login']
Relative XPath is generally more maintainable.
However, XPath is not always the best choice. Use stable IDs or CSS selectors when appropriate.
24. Implicit vs explicit wait?
Web applications often load elements dynamically, so automation needs synchronization.
Implicit wait applies a default waiting period to element lookups.
Explicit wait waits for a particular condition.
Example:
WebDriverWait wait =
new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement button =
wait.until(
ExpectedConditions.elementToBeClickable(
By.id("login")
)
);
Explicit waits are useful because they wait for a specific condition instead of blindly waiting.
Avoid using fixed sleeps everywhere:
Thread.sleep(5000);
They can make tests slower and still fail when the application takes longer than expected.
25. What is the Page Object Model?
Page Object Model, or POM, is a design pattern that separates page-specific locators and actions from test logic.
For example:
public class LoginPage {
private WebDriver driver;
private By username =
By.id("username");
private By password =
By.id("password");
private By loginButton =
By.id("login");
public LoginPage(WebDriver driver) {
this.driver = driver;
}
public void login(String user, String pass) {
driver.findElement(username).sendKeys(user);
driver.findElement(password).sendKeys(pass);
driver.findElement(loginButton).click();
}
}
The test can then call:
loginPage.login(
"user@example.com",
"password"
);
Benefits include:
- Reusability
- Maintainability
- Readability
- Centralised locators
26. What is TestNG?
TestNG is a Java testing framework commonly used with Selenium.
It provides:
- Annotations
- Assertions
- Groups
- Data providers
- Dependencies
- Parallel execution
- Reports
Example:
@Test
public void validLoginTest() {
// test
}
A typical Selenium stack might be:
Java
+
Selenium
+
TestNG
+
Maven
+
Git
+
Jenkins
27. What is a data-driven framework?
A data-driven framework separates test logic from test data.
Instead of creating four login scripts:
User 1
User 2
User 3
User 4
one test can execute using four datasets.
Data may come from:
- CSV
- Excel
- JSON
- Database
- API
The key benefit is:
Test logic is reused while input data changes independently.
28. What is BDD, and what is Cucumber?
BDD stands for Behaviour-Driven Development.
It describes application behaviour in business-readable language.
A common format is:
Given
When
Then
Example:
Scenario: Valid login
Given the user is on the login page
When the user enters valid credentials
And clicks the login button
Then the dashboard should be displayed
Cucumber can execute scenarios written using Gherkin syntax.
BDD can improve communication between developers, testers and business stakeholders.
29. How do you handle alerts, frames and multiple windows in Selenium?
For browser alerts:
Alert alert = driver.switchTo().alert();
alert.accept();
For frames:
driver.switchTo().frame("paymentFrame");
Return to the main document:
driver.switchTo().defaultContent();
For multiple windows:
Set<String> handles =
driver.getWindowHandles();
The important concept is that Selenium interacts with the currently selected browsing context. You must switch to the correct alert, frame or window before interacting with it.
30. What is API testing?
API testing evaluates backend endpoints directly.
For example:
POST /users
with a request body containing user information.
You can validate:
- Status code
- Response body
- Headers
- Response time
- Authentication
- Authorization
- Error handling
- Database changes
Common tools include:
- Postman
- REST Assured
- Playwright API testing
- curl
API testing is important because modern applications often have separate frontend and backend layers.
31. What are common HTTP status codes?
| Status | Meaning |
|---|---|
| 200 | OK |
| 201 | Created |
| 204 | No Content |
| 400 | Bad Request |
| 401 | Authentication required or failed |
| 403 | Forbidden |
| 404 | Not Found |
| 409 | Conflict |
| 422 | Unprocessable Content |
| 429 | Too Many Requests |
| 500 | Internal Server Error |
| 503 | Service Unavailable |
A common interview question is:
401 vs 403?
A simplified explanation:
401 generally means authentication is missing or not accepted, while 403 means access is not permitted.
32. What is CI/CD in testing?
CI/CD allows automated tests to run as part of a software delivery pipeline.
A simplified workflow is:
Developer commits
↓
Git repository
↓
CI pipeline
↓
Build
↓
Unit tests
↓
API tests
↓
UI tests
↓
Report
↓
Deployment
Common tools include:
- Jenkins
- GitHub Actions
- GitLab CI/CD
- Azure DevOps
The objective is to detect problems earlier instead of waiting until the end of a release cycle.
33. Selenium vs Playwright?
Both are widely used browser automation technologies.
| Feature | Selenium | Playwright |
|---|---|---|
| Browser automation | Yes | Yes |
| Browser coverage | Broad | Chromium, Firefox, WebKit |
| Languages | Broad | JavaScript/TypeScript, Python, Java, .NET |
| Auto-waiting | Requires synchronization strategy | Built into actions |
| Parallel execution | Supported through framework and Grid options | Built into Playwright Test |
| Ecosystem | Very mature | Modern and rapidly adopted |
| Common use | Enterprise automation | Modern web automation |
Do not answer:
“Playwright is better.”
A better answer is:
“Both are capable automation tools. Selenium has a mature ecosystem and broad language support, while Playwright provides modern features such as auto-waiting, tracing and parallel execution. The right choice depends on the project and team’s technology stack.”
34. Which tests should not be automated?
Tests that may be better suited to manual execution include:
- One-time tests
- Frequently changing features
- Exploratory testing
- Usability testing
- Visual assessments requiring human judgement
- Scenarios with unclear requirements
- Very low-value tests
The goal is not to automate everything.
The goal is to automate tests where automation provides measurable value.
35. What SQL do testers need?
Freshers should understand:
- SELECT
- WHERE
- ORDER BY
- GROUP BY
- HAVING
- JOIN
- COUNT
- SUM
- MAX
- MIN
- DISTINCT
- NULL handling
- INSERT
- UPDATE
Example:
SELECT *
FROM employees
WHERE department = 'QA';
JOIN:
SELECT e.name, d.department_name
FROM employees e
JOIN departments d
ON e.department_id = d.id;
Aggregation:
SELECT department, COUNT(*)
FROM employees
GROUP BY department;
SQL helps testers verify whether frontend and API actions correctly update backend data.
How to Think Like a QA Engineer
Suppose a requirement says:
“Users can upload profile pictures.”
A beginner may test only:
Upload JPG
A QA engineer should ask:
- What formats are supported?
- What is the maximum size?
- What happens with a corrupted file?
- What happens with a zero-byte file?
- What happens with a duplicate file?
- What happens when the network disconnects?
- Can an unauthorised user upload?
- What happens with special characters in the filename?
- Does it work on mobile?
- Is the uploaded file protected from unauthorised access?
This mindset is one of the most important skills a fresher can demonstrate.
Test Scenario vs Test Case
A test scenario is a high-level functionality or condition to test.
A test case contains detailed steps and expected results.
For example:
Scenario:
Verify login functionality.
Possible test cases:
- Valid credentials
- Invalid username
- Invalid password
- Empty fields
- Locked account
- Expired password
- Invalid email format
- Session timeout
Think:
Test Scenario
↓
Multiple Test Cases
Positive Testing vs Negative Testing
Positive testing checks expected inputs.
Example:
Age = 30
Negative testing checks invalid or unexpected inputs.
Example:
Age = -5
For a phone field:
Positive:
9876543210
Negative:
abcdefghij
Good QA coverage includes both.
What Is End-to-End Testing?
End-to-end testing verifies a complete business workflow.
For an e-commerce application:
Login
↓
Search
↓
Product
↓
Cart
↓
Address
↓
Payment
↓
Order
↓
Confirmation
It may involve the frontend, APIs, database and third-party services.
E2E tests are valuable but can be slower and more fragile than unit or API tests, so they should be used strategically.
What Is Performance Testing?
Performance testing evaluates application behaviour under different workloads.
Load testing
Tests expected user load.
Stress testing
Pushes the system beyond expected capacity.
Spike testing
Tests sudden increases in traffic.
Endurance testing
Tests sustained load over time.
Performance testing can evaluate:
- Response time
- Throughput
- Error rate
- Resource utilisation
- Stability
- Scalability
Tools such as JMeter are commonly used.
What Is Security Testing?
Security testing evaluates whether applications protect data and functionality.
Freshers should understand:
- Authentication
- Authorization
- Session management
- Input validation
- Access control
- Password security
- SQL injection
- XSS
- CSRF
- Sensitive data exposure
Remember:
Authentication = Who are you?
Authorization = What are you allowed to access?
How to Build an Automation Framework as a Fresher
A basic framework can be organised as:
Automation Framework
│
├── Tests
├── Page Objects
├── Utilities
├── Test Data
├── Configuration
├── Reports
└── Driver Management
A Java-based stack might be:
Java
+
Selenium
+
TestNG
+
Maven
+
Page Object Model
+
Git
+
Jenkins
The framework should make tests:
- Reusable
- Maintainable
- Readable
- Scalable
How to Debug a Failed Automation Test
An automation failure does not automatically mean there is a product defect.
Check:
Locator issue
Did the application’s DOM change?
Synchronization issue
Was the element ready?
Test-data issue
Was the user already registered or locked?
Environment issue
Is the test server or API available?
Product defect
Does the application genuinely behave incorrectly?
Flaky test
Does the same test randomly pass and fail?
This diagnostic approach is important for automation engineers.
What Is a Flaky Test?
A flaky test gives inconsistent results without an intentional application change.
Example:
Run 1 → Pass
Run 2 → Fail
Run 3 → Pass
Run 4 → Pass
Run 5 → Fail
Common causes include:
- Poor synchronization
- Shared test data
- Race conditions
- Network instability
- Environment issues
- Test-order dependency
Do not immediately solve flaky tests by adding long sleep() calls. Investigate the underlying cause.
Tools to Learn as a Fresher QA
| Area | Tools |
|---|---|
| Test management | JIRA, TestRail |
| UI automation | Selenium, Playwright |
| Java frameworks | TestNG, JUnit |
| Python | PyTest |
| API | Postman, REST Assured |
| Performance | JMeter |
| Database | MySQL, PostgreSQL |
| Version control | Git |
| CI/CD | Jenkins, GitHub Actions |
| BDD | Cucumber |
| Reporting | Allure and framework reports |
| Build tools | Maven, Gradle |
You do not need to master every tool.
A practical Java QA stack could be:
Java
+
Selenium
+
TestNG
+
Maven
+
Postman
+
SQL
+
Git
+
Jenkins
A Python-oriented stack could be:
Python
+
Selenium
+
PyTest
+
Postman
+
SQL
+
Git
A modern web automation stack could be:
JavaScript/TypeScript
+
Playwright
+
API testing
+
SQL
+
Git
+
CI/CD
Choose based on the jobs you are targeting.
How to Prepare for a Fresher QA Interview
Week 1: Manual Testing
Study:
- SDLC
- STLC
- Testing levels
- Testing types
- Test scenarios
- Test cases
- Defect life cycle
- Severity
- Priority
- Smoke testing
- Sanity testing
- Regression
- Retesting
- Exploratory testing
Write test cases daily.
Week 2: Test Design
Practise:
- Boundary Value Analysis
- Equivalence Partitioning
- Decision tables
- State transitions
- Positive testing
- Negative testing
Use real applications such as:
- ATM
- E-commerce
- Food delivery
- Banking
- Ticket booking
Week 3: Automation
Learn:
- Selenium or Playwright
- Locators
- Waits
- Assertions
- Browser interactions
- Frames
- Alerts
- Windows
- Page Object Model
- Test framework
Build at least 10 practical automated tests.
Week 4: API, SQL and CI/CD
Learn:
- HTTP methods
- Status codes
- JSON
- Postman
- REST APIs
- SQL
- Git
- Basic CI/CD
Then run your automation suite through a simple pipeline.
How to Explain a QA Project in an Interview
Use this structure:
1. Project overview
Explain what the application does.
2. Your role
Explain exactly what you tested.
3. Testing scope
Mention relevant areas such as:
- Functional testing
- Regression
- API testing
- Database testing
- Automation
4. Tools
For example:
JIRA
Selenium
Java
TestNG
Postman
SQL
Git
Jenkins
5. Challenge
Explain one real testing problem.
For example:
The application used dynamic element IDs, causing unstable automation. We switched to stable attributes and improved synchronization.
6. Result
Explain the outcome.
For example:
Critical regression scenarios were automated, reducing repetitive manual execution effort.
This gives the interviewer a concrete understanding of your experience.
Common Fresher QA Interview Mistakes
Memorising definitions
Don’t stop at:
“Regression testing is testing after changes.”
Explain a practical example.
Testing only positive scenarios
Always consider:
- Invalid inputs
- Boundary values
- Empty fields
- Duplicate actions
- Unexpected sequences
- Network failures
Confusing retesting and regression
Remember:
Retesting → Verify the fix
Regression → Verify existing functionality
Thinking automation replaces manual testing
Automation executes predefined instructions.
A tester still decides:
- What to automate
- What to test
- What risks matter
- What unexpected behaviour requires investigation
Using fixed waits everywhere
Avoid treating:
Thread.sleep(5000);
as your primary synchronization strategy.
Ignoring SQL
SQL allows testers to verify backend data instead of relying only on the UI.
Ignoring APIs
Modern applications frequently depend on APIs, so API testing is an important QA skill.
Claiming tools you have never used
If you only completed a Selenium tutorial, say you have learning or project experience rather than claiming professional expertise.
Frequently Asked Questions
Is manual testing still a good career in 2026?
Manual testing remains important, particularly for exploratory, usability, ad-hoc and business-focused testing. However, freshers can strengthen their profiles by learning automation, API testing, SQL and basic CI/CD.
Which language is best for automation testing?
There is no universal best language.
Java remains common in Selenium-based enterprise automation. Python is popular for its accessible syntax and testing ecosystem. JavaScript and TypeScript are particularly relevant to modern web automation.
The practical choice depends on the jobs you are targeting.
How long does it take to learn software testing?
A motivated beginner can build a foundation in manual testing and automation basics in approximately three months with consistent practice.
A practical progression is:
Month 1 → Manual testing
Month 2 → Automation
Month 3 → API + SQL + Git + CI/CD
Actual job readiness depends on prior programming knowledge, practice and role requirements.
Do testers need coding?
For manual roles, coding requirements vary.
For automation roles, programming is important.
You should understand:
- Variables
- Conditions
- Loops
- Functions
- Collections
- Exceptions
- File handling
- APIs
- Debugging
SQL is also valuable for database validation.
Is Selenium enough to get an automation job?
Selenium alone is unlikely to be enough.
You should also understand:
- Programming
- Test frameworks
- Locators
- Waits
- Page Object Model
- API testing
- SQL
- Git
- CI/CD
- Debugging
Should I learn Selenium or Playwright first?
Look at the job descriptions you are targeting.
If roles commonly mention Java, Selenium and TestNG, that combination is practical.
If roles mention JavaScript or TypeScript and Playwright, prioritise Playwright.
Selenium has a mature ecosystem and broad language support, while Playwright provides modern features such as auto-waiting, tracing and parallel execution.
What SQL should freshers know?
Practise:
- SELECT
- WHERE
- ORDER BY
- GROUP BY
- HAVING
- JOIN
- COUNT
- SUM
- MAX
- MIN
- DISTINCT
- NULL handling
You should be able to use SQL to verify application data.
What API questions should freshers practise?
Prepare for:
- What is an API?
- What is REST?
- GET vs POST?
- PUT vs PATCH?
- Authentication vs authorization?
- What is JSON?
- What are HTTP status codes?
- How do you test APIs in Postman?
- How do you validate response data?
- How do you test negative scenarios?
What should I practise before the interview?
Before your interview, make sure you can confidently explain:
- SDLC
- STLC
- Test scenarios
- Test cases
- Positive and negative testing
- Boundary Value Analysis
- Equivalence Partitioning
- Smoke testing
- Sanity testing
- Regression testing
- Retesting
- Defect life cycle
- Severity and priority
- Exploratory testing
- UAT
- RTM
- Selenium or Playwright
- Locators
- Waits
- Page Object Model
- Test frameworks
- API testing
- HTTP status codes
- SQL
- Git
- CI/CD
- Your QA project
Final Interview Preparation Checklist
The best way to prepare for a fresher QA interview is to combine testing fundamentals with hands-on technical practice. Start with SDLC, STLC, test-case design, boundary value analysis, equivalence partitioning, defect management, severity, priority, regression and exploratory testing. Then learn one automation stack such as Java with Selenium and TestNG, Python with Selenium and PyTest, or JavaScript/TypeScript with Playwright. Add API testing with Postman, SQL for database validation, Git for version control and basic CI/CD concepts. Most importantly, build one practical QA project that includes test cases, defect reports, API testing, database validation and automation. During the interview, avoid giving memorised definitions without examples. Explain how you would test a feature, what could go wrong, how you would investigate failures and which scenarios you would automate. That combination of testing knowledge, technical skills and problem-solving ability gives freshers a strong foundation for QA and automation roles in 2026.
