Introduction: Why Companies Conduct Interview Written Tests
Before face-to-face interviews, many companies conducted a written test round. This round helps recruiters filter candidates quickly based on basic knowledge, logical thinking, and problem-solving skills.
That is why interviewed written test questions and answers are extremely important for job seekers, especially freshers and early-career professionals.
Companies use written tests to check:
- Basic understanding of software testing concepts
- Logical reasoning and clarity of thought
- Ability to apply concepts to real-time scenarios
- Readiness for technical and HR interview rounds
Written tests are commonly used in:
- Campus placements
- Walk-in interviews
- Mass hiring drives
- Service-based and product-based companies
This article is designed to help you clear the written test round confidently, even if you are fresher.
Why Written Test Rounds Are Important
Written tests help companies evaluate candidates before technical interviews. These rounds are usually conducted to shortlist candidates efficiently from a large number of applicants.
Main Purpose of Written Tests
Recruiters use written tests to assess:
- Fundamental technical knowledge
- Analytical thinking ability
- Problem-solving approach
- Communication clarity
- Time management skills
What Companies Usually Check in Written Tests
Basic Software Testing Knowledge
Questions may cover topics such as:
- SDLC and STLC
- Types of testing
- Defect lifecycle
- Test case design
- Regression testing
- Smoke and sanity testing
Logical Reasoning Skills
Many companies include reasoning questions to evaluate:
- Logical thinking
- Pattern recognition
- Analytical ability
- Decision-making skills
Real-Time Scenario Understanding
Interviewers may provide simple practical situations to check whether candidates can apply testing concepts correctly.
Examples include:
- How to test a login page
- How to handle a rejected defect
- What to do when requirements change
Readiness for Technical Interviews
Written tests also help companies evaluate whether candidates are prepared for:
- Technical interview rounds
- Scenario-based discussions
- HR interviews
- Communication-based evaluations
What Is Software Testing? (Simple Explanation for Written Tests)
Software testing is the process of verifying and validating a software application to ensure it works as expected and meets business requirements.
In simple words, testing helps identify bugs, errors, or issues before the software is released to users.
The main goal of software testing is to ensure that the application is:
- Working correctly
- Meeting user requirements
- Secure and reliable
- Easy to use
- Free from critical defects
Simple Example
Consider a login page. Testing checks whether the application:
- Allows valid users to log in
- Rejects invalid credentials
- Shows proper error messages
- Redirects users correctly after login
- Works properly on different browsers and devices
If all these functionalities work correctly, the software passes testing.
Why Software Testing is Important
Software testing is important because it helps to:
- Improve software quality
- Reduce production issues
- Enhance user experience
- Prevent business losses caused by defects
- Ensure the application behaves as expected
Without proper testing, users may face crashes, data loss, security problems, or incorrect functionality.
Interview Tip
In interviews, keep your answer short, simple, and clear.
Avoid giving long textbook definitions. Instead, explain testing in practical and easy-to-understand language with a simple example.
Common Interview Written Test Questions and Answers
Below are frequently asked interview written test questions and answers that appear in aptitude + technical rounds.
1. What is software testing?
Answer:
Software testing is the process of evaluating a system with the intent of finding bugs. It is performed to check if the system satisfies its specified requirements and quality standards. It evaluates the system to validate its functionality.
Testing measures the system’s overall quality in terms of correctness, completeness, usability, performance, and other functional and non-functional attributes.
Software testing is not associated with uncovering potential bugs or defects. It also involves finding measures to improve the system’s efficiency and accuracy.
Basically, software testing is the combination of verification and validation.
2. Why is software testing required?
Answer:
Software testing is important because it ensures a software application works correctly before users interact with it. Without testing, a software product may contain hidden defects that affect functionality and reliability.
Testing software helps development teams confirm that the software system performs according to specified requirements. It also prevents costly errors and improves overall software reliability.
Thorough testing allows organizations to deliver a high-quality product that meets user expectations. In modern software development, testing has become a critical part of the development process.
1. What is manual testing?
Answer:
Manual Testing is the most fundamental approach in the Software Testing Life Cycle (STLC). It is the process of manually testing software applications without the use of automation tools. The tester acts as the end-user and validates whether the software behaves as expected. Despite the growth of automation testing, manual testing remains essential because it helps in identifying usability issues, visual inconsistencies, and unexpected behavior that automation tools may miss.
In this article, we’ll cover the basics of manual testing, different types of manual testing, and examples to understand how it works in real-life projects.
Basics of Manual Testing
Manual Testing focuses on ensuring that the application is functioning correctly based on the given requirements. Here are the core fundamentals:
1. No Automation Tools Used
Testers execute test cases manually, step by step.
Tools like JIRA, Bugzilla, and Trello are used for tracking defects, but execution is done without code/scripts.
2. End-User Perspective
The tester plays the role of the actual user.
Validates both functionality and user experience.
3. Test Documentation
Includes Test Plan, Test Cases, Test Scenarios, and Bug Reports.
Example of a simple test case format:
4. Validation and Verification
Verification: Making sure the product is constructed appropriately (in accordance with specifications).
Validation: Making sure the appropriate product is created for the final consumer.
Manual Testing Types
Depending on the requirements of the project, manual testing uses a variety of testing techniques. The most typical kinds are listed below:
1. Unit Testing
Performed individual components or modules.
Developers usually do it, but manual testers may validate test data.
2. Integration Testing
ensures to work together two or more units.
Example: Testing that the user dashboard and login page work together.
3. System Testing
validates the application as a whole.
An e-commerce app’s overall testing, from login to checkout, is an example.
4. Smoke Testing
Build Verification Testing be another word on it.
A quick check to make sure the fundamental features are operational.
For example, checking if an app installs correctly and opens without crashing.
5. Sanity Testing
narrow and targeted testing after small changes.
Example: The tester only rechecks login after resolving a login bug.
6. Regression Testing
ensures that new changes do not cause problems with existing features.
Example: The tester rechecks the dashboard and login after adding an “Forgot Password” feature.
7. Usability Testing
emphasizes experience and user-friendliness.
Example: Verifying that the “Sign Up” button is accessible and visible.
8. Acceptance Testing
This is done to confirm that the application satisfies business needs.
often carried out during the User Acceptance Testing (UAT) stage.
9. Exploratory Testing
No predefined test cases; the tester explores the app.
Helps in finding unexpected defects.
10. Ad-hoc Testing
informal testing that is not recorded.
Example: Randomly trying invalid inputs to check system stability.
Instances of Manual Testing in Actual Projects
2. Why is manual testing important?
Answer:
Human Perspective: The basic usability and look & feel of the application can only be gazed and evaluated by Humans. As the software is developed for humans only, they only can-do better justice of validation from a user experience perspective.
A broader perspective and variation of the System workflows: Manual verification always gives a broader perspective of the overall application. As the human mind will always be in an exploratory form, instead of a coding mechanism that executes the same steps each time. So, it will provide more expansive coverage for system validation.
Cost of automation: Sometimes, due to the timelines or size of the project, the extended efforts for the automation are not justifiable, and we always prefer a quick manual validation over the automation testing.
Un-automatable scenarios: There can be multiple scenarios that are either not worth automating and doesn’t give clear confidence of the user behavior when just testing using automation. For Example, there have been multiple scenarios on mobile devices, which need user interactions, such as “Tap & Pay”, which sometimes have different behaviors when automated using tools and when a person manually validated them.
3. What is a test case?
Answer:
A test case is a set of actions performed on a system to determine if it satisfies software requirements and functions correctly. The purpose of a test case is to determine if different features within a system are performing as expected and to confirm that the system satisfies all related standards, guidelines, and customer requirements. The process of writing a test case can also help reveal errors or defects within the system.
Test cases are typically written by members of the quality assurance (QA) team or the testing team and used step-by-step instructions for each system test. The testing process begins once the development team has finished a system feature or set of features. A sequence or collection of test cases is called a test suite.
4. What is a test scenario?
Answer:
A high-level description of a functionality that must be tested is called a test scenario. Sometimes referred to as a test situation, it represents a possible user interaction or system behavior. Put yourself in the end user’s position as a tester and identify the application under test’s (AUT) real-world scenarios and use cases.
Test scenarios can be classified based on what aspect of the application they aim to verify. Understanding these types ensures full coverage of all functionality and user interactions.
Various Test Scenario Types
Functional Scenarios: These verify if particular modules or features (such as login, signup, or checkout) work according to requirements. They focus on “what it should do.”
Non-Functional Scenarios: These assess the system’s performance, scalability, usability, and reliability rather than what it does.
Security Scenarios: These evaluate how well the program guards user information and stops vulnerabilities or illegal access.
UI (User Interface) Scenarios: These ensure the interactive elements, navigation, and visual layout work naturally on various screens and devices.
End-to-End Scenarios: These simulate real -world workflows and verify that several modules cooperate smoothly. An eCommerce app search, cart addition, and payment completion are a few examples.
5. What is a defect or bug?
Answer:
A bug in software testing refers to an error in the code that causes the software to behave differently than expected. It occurs when the actual result of a function does not match the expected result during any stage of development.
In simpler terms, a bug is an issue that prevents a software system from working correctly. These errors can be found at any phase, from coding to integration testing, and they can lead to major issues if not detected early.
6. What is STLC?
Answer:
- The Software Testing Life Cycle (STLC) is a structured framework that guides testing from initial requirements through final validation and retrospective. Instead of treating testing as an afterthought, STLC makes it a disciplined, repeatable process that catches issues before they reach users. Its core phases stay consistent across Scrum, Kanban, and Waterfall, making it adaptable to virtually any team.
- For modern teams building AI-driven systems, execution depends on having the right people in place. Platforms like Fonzi AI help companies quickly hire experienced engineers and QA specialists who can implement automated, STLC-aligned workflows, so recruiters and technical leaders can build reliable systems without sacrificing speed.
7. Explain STLC phases
Answer: There are several phases involved in the STLC, and the key phases are:
Requirement Analysis:
In this phase, the software requirements are analyzed and documented. This involves understanding the client’s requirements, identifying the scope of the project, and determining the testing objectives.
Test Planning:
In this phase, the testing team prepares a test plan that outlines the approach, resources, and schedule for the testing process. This includes identifying the software testing types, techniques, tools, and environments to be used, as well as defining the roles and responsibilities of the team members.
Test Design:
In this phase, the testing team designs the test cases, scenarios, and scripts based on the requirements and test plan. This includes identifying the input data, expected outcomes, and validation criteria for each test case.
Test Execution:
In this phase, the testing team executes the test cases, scenarios, and scripts according to the test plan. This involves running the tests and recording the results, as well as identifying and reporting defects.
Test Reporting:
In this phase, the testing team prepares test reports that summarize the testing process and results. This includes documenting the test cases executed, defects found, and overall quality of the software product.
Test Closure:
In this phase, the testing team evaluates the testing process and the software product against the testing objectives and criteria. This involves reviewing the test reports, identifying areas for improvement, and making recommendations for future testing activities.
8. What is smoke testing?
Answer:
Smoke testing checks the basic functionality of a software program. Its purpose is to test whether the software can perform the tasks it’s designed to carry out without “smoking,” or failing.
Ideally, teams should run smoke tests at key checkpoints in the QA workflow (for example, after a new build or deployment to a test environment). Together with sanity testing, smoke testing is a great way to make sure that the software performs its basic functions after each update.
9. What is sanity testing?
Answer:
Sanity Testing
Sanity testing is a narrow, high-level check performed after small code changes such as bug fixes or minor enhancements. This focused testing helps verify that the specific functionality affected still works correctly.
Purpose of Sanity Testing
- Verifies that recent changes have not broken the related functionality
- Ensures the application is stable enough for further testing
- Acts as a quick validation step before proceeding
Role in Testing Process
- Serves as a checkpoint to decide whether deeper testing (like full regression) is necessary
- Helps teams avoid wasting time on unstable or broken builds
- Supports efficient test execution by focusing only on impacted areas
10. What is regression testing?
Answer:
Regression Testing is defined as a type of software testing to confirm that a recent program or code change has not adversely affected existing features. We can also say it is nothing but a full or partial selection of already executed test cases that are re-executed to ensure existing functionalities work fine.
This type of testing is done to ensure that new code changes do not have any side effects on existing functionalities. It ensures that the old code still works once the latest code changes are done.
11. What is retesting?
Answer:
Retesting in Software Testing
Retesting is a crucial software testing process where specific test cases are executed again to ensure that defects identified in previous tests have been fixed correctly. It helps verify that the modifications or bug fixes have not introduced new issues.
Retesting guarantees the reliability and quality of the software before its release.
Purpose of Retesting
- Ensures that previously identified defects are fixed correctly
- Verifies that bug fixes have not introduced new issues
- Confirms the stability of the affected functionality
- Improves overall software quality before release
Role in Defect Life Cycle
- Retesting is part of the defect life cycle
- It involves testing of failed test cases that were non-functional during earlier testing
- These test cases are executed again after developers fix the defects
- Ensures that the defect is completely resolved before closure
12. What is black box testing?
Answer:
Black box testing examines software functionality without examining its internal code structure. In this approach, testers interact with applications just as end users would, verifying that the system behaves according to requirements.
Also known as closed-box testing, this technique ensures applications fulfill their functional expectations regardless of how they’re coded.
Consider a simple login page black box testing example:
- You enter a username and password, then click the login button
- You then see what happens next
- If credentials are correct, the system should grant access and display the dashboard
- If details are incorrect, it should present an appropriate error message (like “Invalid credentials”)
Throughout this process, testers never examine the underlying authentication code or password verification logic.
Instead, they focus exclusively on what goes in (input) and what comes out (output). This forms the essence of black box testing: treat the application as a sealed box, provide various inputs, and assess whether the outputs align with expected results.
13. What is white box testing?
Answer:
The white box testing is a procedure that includes verification of the internal structure, and logic of the software. A tester who is in charge of this has complete access to the source code. He uses his knowledge of the internal working of the software, and his technical skills to create tests that can validate the code. The software for white box testing is also called transparent testing, open box testing, structural testing, or code-based testing.
The verification of the software interior algorithm, flow, and structure is the main objective of the white box testing. The white box test cases cover the different paths of the code, and logic to ensure that the user’s specifications are met.
14. What is exploratory testing?
Answer:
Exploratory testing is a type of software testing where testers explore the application freely without following predefined test cases or detailed documentation.
The tester simultaneously learns, designs, and executes tests during the testing process.
15. What is functional testing?
Answer:
Functional testing is performed to verify whether the application works according to business and functional requirements.
16. What is non-functional testing?
Answer:
Non-functional testing is a software testing type that tests the non-functional aspects of an application, such as usability, performance, scalability, reliability, security, compatibility, and more. In contrast, functional testing focuses on testing its functional behavior.
17. What is severity?
Answer:
Severity is the degree of impact that a defect has on the operation of the product.
18. What is priority?
Answer:
Priority is the order in which the developer should resolve a defect.
19. Difference between severity and priority
- Answer:We have talked about various forms of both terms. Now, let’s look at the key differences which make them distinct.
- The term severity defines, to what degree the system is impacted. Whereas priority is all about scheduling or urgency.
- Usually, it is the test engineer who determines severity. While the product owners decide the priorities of defects.
- It is very unlikely that severity might change. Whereas the priorities change from time to time.
- Severity is usually determined from a technical point of view. Whereas priority depends upon the user experience.
- The severity affects the technical working of the system. Whereas the latter affects business.
- Severity and Priority Real-time Examples
- The priority and severity are combined in four different ways to determine which defect needs immediate attention and which one the least. Let’s look at some real-time examples to make this concept even more clear.
- High Priority and High Severity Examples
- The products added to the cart of an e-commerce website are not visible on the payment page.
- The login button of the application is not working.
- High Priority and Low Severity Examples
- The logo of the company’s welcome page is distorted.
- The action buttons are not visually appealing, or the information on the page appears hazy.
- Low Priority and High Severity Examples
- If the application is crashing on passing very large input for processing (which is very rarely done).
- There are some buttons on the website which are overlapping. Although clickable, create a fuss.
- Low Priority and Low Severity Examples
- A spelling mistake on the page of the site which is not frequently visited.
- The color of any text does not match the theme of the website.
20. What is a defect lifecycle?
Answer:
The defective life cycle (also called bug life cycle) is the sequence of states a software defect passes through from initial discovery until final closure. Every defect follows a defined path: it gets reported, assigned, fixed, verified, and closed.
- Understanding this cycle matters because it directly affects how quickly your team resolves issues and how reliably your software performs. Teams that manage defects well ship better products faster. Teams that do not end up with confused developers, frustrated testers, and buggy releases.
- This guide covers everything you need to manage defects effectively: the standard states and transitions, how to distinguish severity from priority, writing defect reports that developers can use, and selecting the right tools for your team.
21. What is UAT?
Answer:
User Acceptance Testing (UAT) is a type of testing performed by the end user or the client to verify/accept the software system before moving the software application to the production environment. UAT is done in the final phase of testing after functional, integration, and system testing is done.
22. What is a test environment?
Answer:
A test environment is a setup created for testers to execute test cases and validate application functionality.
It includes all the hardware, software, tools, databases, and configurations required for testing.
23. What is test coverage?
Answer:
Test coverage is a measurement that shows how much of the application’s functionality, requirements, or code has been tested.
It helps ensure that all important features and scenarios are validated during testing.
24. What is defect leakage?
Answer:
Defect leakage is a situation where defects are not identified during the testing phase and are found later by users or customers in the production environment.
It means the defect “leaked” from the testing phase into the live application.
25. What is a test plan?
Answer:
Test Plan is a detailed document that outlines the objective, strategies, timeline, goals, estimation, deadlines, and resources needed for the successful completion of a project. It provides a framework that is designed by QA managers to provide clarity about the necessary tests that you need to verify to ensure the proper functioning of the software.
Multiple-Choice Style Questions (Very Common in Written Tests)
26. Which testing is done first?
A. Regression
B. Sanity
C. Smoke
D. UAT
Answer: C – Smoke testing
Explanation
Smoke testing is performed first to verify whether the basic functionality of the application is working properly before detailed testing begins.
27. Which document is prepared first?
A. Test case
B. Test plan
C. Defect report
D. RTM
Answer: B – Test plan
Explanation
The test plan is prepared first because it defines the testing scope, strategy, objectives, resources, and schedule for the project.
28. Bug found in production is called?
A. Bug release
B. Bug leakage
C. Bug fix
D. Bug closure
Answer: B – Bug leakage
Explanation
Bug leakage occurs when a defect is missed during testing and is discovered later in the production environment by users or clients.
29. Who performs UAT?
A. Developers
B. Testers
C. End users
D. Managers
Answer: C – End users
Explanation
User Acceptance Testing (UAT) is usually performed by end users or clients to verify whether the application meets business requirements.
30. Which testing checks performance?
A. Functional
B. Regression
C. Load
D. Smoke
Answer: C – Load testing
Explanation
Load testing is a type of performance testing used to evaluate how the application behaves under expected user load and traffic conditions.
Real-Time Scenario Based Written Test Questions
Many written tests now include scenario-based responses.
1. Login Button Is Not Clickable
Answer
Log a defect with steps to reproduce, screenshots, and expected behavior.
2. Application Crashes After Submit
Answer
Reproduce the issue and report it as a high-severity defect.
3. Password Is Visible
Answer
This is a security defect.
4. Application Works in Chrome but Not Firefox
Answer
This is a browser compatibility issue.
5. Page Loads Slowly
Answer
This is a performance issue.
6. Duplicate Records Created
Answer
This is a functional defect.
7. Error Message Is Incorrect
Answer
This is a UI or validation defect.
8. Data Not Saved After Refresh
Answer
This may be a backend or functional issue.
9. Broken Link Found
Answer
Log a defect with the broken URL details.
10. Logout Not Working
Answer
This is a critical functional defect.
Additional Common Written Test Scenarios (11–15)
Other Frequently Asked Scenarios
- Mandatory field validation missing
- Incorrect success message
- UI alignment issue
- Search results incorrect
- Session timeout issue
Why Interviewers Ask Written Test Questions
Interviewers use interview written test questions and answers to:
- Filter large numbers of candidates
- Check basic technical awareness
- Evaluate logical thinking
- Reduce interview time
Written tests help companies shortlist serious and well-prepared candidates.
How to Answer Written Test Questions Effectively
Best Strategy
- Keep answers short and direct
- Use important keywords
- Avoid unnecessary explanations
- Read questions carefully before answering
Example
Question
What is regression testing?
Best Answer
“Testing performed to ensure existing functionality works properly after changes or new updates.”
Quick Revision Shortlist (Before Written Test)
Revise These Topics Before the Exam
- Software testing basics
- Manual vs automation testing
- STLC and defect lifecycle
- Smoke, sanity, and regression testing
- Basic real-time testing scenarios
FAQs – Interview Written Test Questions and Answers
Q1. Are written tests compulsory?
No, written tests are not compulsory in every company, but many companies still conduct them, especially freshers and early-career candidates.
Whether a written test is included depends on:
- Company hiring process
- Experience level
- Type of company
- Number of applicants
- Role requirements
Q2. Are answers evaluated strictly?
Yes, written test answers are usually evaluated carefully, but the strictness depends on the company, role, and experience level.
Most companies do not expect perfect textbook answers. Instead, they mainly check whether you understand the concept clearly and can answer logically.
Q3. Do written tests include coding?
Yes, some written tests include coding questions, but it depends on the role, company, and experience level.
For manual testing roles, coding questions are usually limited or not included. However, for automation testing, ETL testing, SDET, or developer-related roles, coding rounds are much more common.
Q4. How much time is given?
The time given for a written test depends on the company, role, and number of questions, but most software testing written tests usually last between 30 minutes to 2 hours.
Q5. How should I prepare?
The best way to prepare is to combine:
- Concept revision
- Scenario practice
- Mock tests
- Time management
Written tests usually check both technical knowledge and logical thinking, so preparation should be practical and structured.
Step-by-Step Preparation Plan
1. Revise Software Testing Basics
Start with core concepts because these are asked in almost every written test.
Important Topics
- SDLC & STLC
- Defect lifecycle
- Smoke, sanity, and regression testing
- Functional vs non-functional testing
- Severity vs priority
- Test case and test scenario
- Verification vs validation
Focus on understanding concepts clearly instead of memorizing long definitions.
2. Practice Scenario-Based Questions
Scenario questions are very common.
Examples
- Login button not working
- Password visible on screen
- Application crashes after submitting
- Duplicate records created
- Browser compatibility issue
Practice giving:
- Short
- Logical
- Direct answers
3. Prepare SQL Basics
Very important for:
- ETL testing
- Database testing
- Backend QA roles
Revise
- SELECT queries
- WHERE clause
- JOINs
- GROUP BY
- COUNT() and aggregate functions
- Duplicate record queries
Even basic SQL knowledge gives a strong advantage.
4. Practice Aptitude and Logical Reasoning
Especially important for:
- Freshers
- Campus placements
- Service-based company hiring
Common Topics
- Percentages
- Ratios
- Time and work
- Number series
- Logical puzzles
- Analytical reasoning
Daily practice improves speed and confidence.
5. Improve Time Management
Written tests are time-based.
Best Strategy
- Solve easy questions first
- Avoid spending too much time on one question
- Practice mock tests with a timer
- Learn to answer quickly and accurately
6. Prepare Short and Clear Definitions
Interview written tests usually prefer concise answers.
Example
Question:
What is regression testing?
Good Answer:
“Testing performed to ensure existing functionality works correctly after changes.”
Short and clear answers usually score better.
7. Revise Real-Time Testing Scenarios
Prepare situations related to:
- Production defects
- UI issues
- Performance problems
- Data mismatch
- Browser compatibility
- Validation issues
These are commonly asked in written tests and interviews.