Testing is crucial to the success of any software product in this competitive world. Manual tests play a pivotal role in software development and come in handy whenever you have a case where you cannot use automated tests. Hence, there is still a lot of demand for people with skills relevant to manual testing. This Manual Testing Interview Questions article is the perfect guide for you to master software testing.
Let’s begin by taking a look at the most frequently asked Manual Testing Interview Questions.
Top 75+ Manual Testing Interview Questions and Answers
For better understanding, the Interview Questions are divided into the following sections:
- Basic Manual Testing Interview Questions
- Advanced Level Manual Testing Interview Questions
- Real-World Based Manual Testing Interview Questions
Basic Manual Testing Interview Questions
Q1. What is Software Testing?
Software Testing is a process used to identify developed software’s correctness, completeness, and quality. It includes a series of activities conducted to find software errors and correct them before the product is released to the market.
Q2. How does quality control differ from quality assurance?
| Quality Control | Quality Assurance |
Quality control is a product-oriented approach to running a program to determine whether it has defects and ensure that the software meets all of the stakeholders’ requirements. | Quality assurance is a process-oriented approach that focuses on making sure that the methods, techniques, and processes used to create quality deliverables are applied correctly. |
3. Why is Software Testing Required?
Software testing is a mandatory process that guarantees that the software product is safe and good enough to be released to the market. Here are some compelling reasons to prove testing is needed:
- It points out the defects and errors that were made during the development phases.
- Reduces the coding cycles by identifying issues at the initial stage of the development.
- Ensures that software application requires lower maintenance costs and result in more accurate, consistent, and reliable results.
- Testing ensures that the customer finds the organization reliable and that their satisfaction with the application is maintained.
- Makes sure that software is bug-free and the quality of the product meets the market standard.
- Ensures that the application doesn’t result in any failures.
Q4. What are the two main categories of software testing?
Software testing is a huge domain but it can be broadly categorized into two areas such as :
- Manual Testing—This is the oldest type of software testing, in which the testers manually execute test cases without using any test automation tools. It means the software application is tested manually by QA testers.
- Automation Testing – This is the process of using the assistance of tools, scripts, and software to perform test cases by repeating pre-defined actions. Test Automation focuses on replacing manual human activity with systems or devices that enhance efficiency.
Q5. What is quality control? Is it similar to Quality Assurance?
Quality control is a product-oriented approach to running a program to determine whether it has defects and ensure that the software meets all of the stakeholders’ requirements.
Q6. What different types of manual testing are there?
Different types of manual testing are;
- Black Box Testing
- White Box Testing
- Unit Testing
- System Testing
- Integration Testing
- Acceptance Testing
Q7. Explain the difference between alpha testing and beta testing.
- Alpha Testing is a type of software testing performed to identify bugs before releasing the product to real users or the public. It is also a type of user acceptance testing.
- Beta Testing is a type of user acceptance testing that is performed by real users of the software application in a real environment.
Q8. What are the different levels of manual testing?
Four levels of manual testing are:
- Unit testing is a way of testing the smallest piece of code, referred to as a unit, that can be logically isolated in a system. It is mainly focused on the functional correctness of the standalone module.
- Integration Testing is a level of software testing where individual units are combined and tested to verify whether they are working as they intend to when integrated. The main aim here is to test the interface between the modules.
- System Testing—In system testing, all the software components are tested as a whole to ensure that the overall product meets the specified requirements. There are dozens of types of system testing, including usability testing, regression testing, and functional testing.
User Acceptance Testing – The final level, acceptance testing, or UAT (user acceptance testing), determines whether or not the software is ready to be released.
Top 50 Manual Testing Interview Questions | Software Testing Interview Preparation | Edureka
This Edureka video on “Manual Testing Interview Questions and Answers” will help you to prepare yourself for Software Testing Interviews based on manual testing.
Q9. What is a testbed in manual testing?
The testbed is an environment configured for testing. It is used for testing an application, including the hardware and any software needed to run the program to be tested. The testbed consists of hardware, software, network configuration, an application under test, and other related software.
Q10. Explain the procedure for manual testing.
The manual testing process comprises the following steps:
- Planning and Control
- Analysis and Design
- Implementation and Execution
- Evaluating exit criteria and Reporting
- Test Closure activities
Q11. What is a test scenario?
A test scenario in software testing is a detailed description of a specific functionality to be tested. It outlines conditions, inputs, and expected outcomes for testers to follow. By replicating real-world interactions, test scenarios help uncover defects and ensure the software meets requirements. Test scenarios aid in identifying issues early, allowing timely resolution before release, contributing to a reliable software product.
Q12. What is GUI testing?
GUI (Graphical User Interface) testing is a software testing technique focused on evaluating the visual and interactive aspects of a software application. It involves verifying that the user interface elements, such as buttons, menus, forms, and windows, function correctly and display accurately. GUI testing ensures that user interactions with the application are smooth, intuitive, and aligned with design specifications. Testers assess aspects like layout, font, color schemes, responsiveness, and alignment of graphical elements. GUI testing is essential to guarantee a positive user experience and identify any discrepancies between the intended design and the actual appearance and behavior of the application. By addressing issues early in the development cycle, GUI testing helps enhance usability, user satisfaction, and the overall quality of the software product.
Q13. When should testing end?
Software testing should end when the predetermined testing objectives have been achieved and the software meets the specified quality criteria. Testing concludes when all test cases have been executed, defects have been identified and resolved, and the software functions as intended. However, it’s essential to consider factors such as time constraints, budget, and the acceptable level of risk. While complete elimination of defects is improbable, testing should halt when the benefits of additional testing no longer justify the resources expended. A balance between thorough testing and timely release is crucial, ensuring that the software is stable, functional, and aligns with user expectations.
Q14. What are the different types of Software testing?
Software testing encompasses various types aimed at ensuring the quality, functionality, and reliability of software applications. Unit testing verifies individual components in isolation. Integration testing assesses interactions between integrated components. Functional testing validates if the software functions as specified. Regression testing ensures new changes don’t adversely affect existing functionalities. Performance testing evaluates the system’s responsiveness and scalability under different conditions. Security testing examines vulnerabilities and safeguards against threats. User Acceptance Testing (UAT) involves end-users validating software suitability. Compatibility testing checks software behavior across different platforms. Usability testing assesses user-friendliness and overall user experience. Exploratory testing involves dynamic, ad hoc testing. Automation testing uses scripts to execute tests. Load testing gauges the application’s response under heavy load. Each type targets specific aspects, collectively ensuring a comprehensive evaluation of the software’s capabilities and performance before deployment.
Q15. What is Acceptance testing?
Acceptance testing is a critical phase in software testing. It evaluates a software application to determine whether it meets the specified requirements and is ready for deployment. It involves validating that the software aligns with user expectations, functions as intended, and satisfies the defined acceptance criteria.
There are two main categories of acceptance testing:
1. User Acceptance Testing (UAT): In UAT, end-users or stakeholders perform tests to ensure that the software meets their needs and requirements. This testing phase confirms that the software is user-friendly, fits into the users’ workflows, and provides the desired functionalities.
2. Business Acceptance Testing (BAT): BAT focuses on validating that the software fulfills the business objectives and goals. It ensures that the software aligns with the organization’s strategic goals and supports the intended business processes.
Acceptance testing acts as the final gate before software release. Its successful completion indicates that the software is ready for deployment to a wider audience. Any issues identified during acceptance testing are addressed, and once the software passes this testing phase, it signifies that it has met the necessary quality standards and is deemed acceptable for production use.
Q16. Differentiate between bug leakage and bug release
Bug Leakage:
Bug leakage occurs when a defect that was previously reported and fixed reappears in the software after it was thought to be resolved. This usually happens when the testing team fails to identify the recurrence of the bug during retesting or regression testing. It indicates that the bug was not completely fixed or that the testing process might have missed certain scenarios that trigger the bug. Bug leakage can lead to a decrease in user confidence and dissatisfaction if users encounter the same issue post-release.
Bug Release:
Bug release refers to the presence of defects or bugs in the software that are identified after the software has been released to the users or clients. These bugs were not detected during the testing process and were inadvertently included in the released version. Bug releases can happen due to various reasons, such as incomplete testing, inadequate test coverage, or unforeseen scenarios. They can result in user inconvenience, reputational damage, and the need for urgent patches or updates to fix the released bugs.
Q17. What is a test script?
A test script is a set of instructions or lines of code written to automate the execution of test cases during software testing. It outlines the sequence of actions that need to be performed by the testing tool or framework to simulate user interactions with the software. Test scripts specify inputs, expected outcomes, and validation criteria for each step, allowing for repeatable and consistent testing. By automating test cases through scripts, testing efficiency is improved, and manual effort is reduced. Test scripts are particularly valuable for regression testing, where repetitive tests need to be executed to ensure that new changes haven’t introduced defects.
Commonly, applications have three separate layers:
- Presentation Layer or user interface
- Business Layer or application user interface for business logic processing
- Database Layer for modeling and manipulating data
API testing is performed at the most critical layer of software architecture, the Business Layer.
Related Article: Selenium Interview Questions
Q18. What’s the difference between verification and validation in testing?
| Verification | Validation |
It is a static analysis technique. In this technique, testing is done without executing the code. Examples include Reviews, Inspections, and walkthroughs. | It is a dynamic analysis technique where testing is done by executing the code. Examples include functional and non-functional testing techniques. |
Q19. What’s the difference between a bug and a defect?
A bug is a fault in the software that’s detected during testing time. A defect is a variance between expected results and actual results detected by the developer after the product goes live.
Q20.What are the advantages of manual testing?
Merits of manual testing are:
- It is a cheaper way of testing when compared to automated testing
- Analysis of product from the point of view of the end-user is possible only with manual testing
- GUI testing can be done more accurately with the help of manual testing, as visual accessibility and preferences are difficult to automate
- East to learn for new people who have just entered into testing
- It is highly suitable for short-term projects when test scripts are not going to be repeated and reused thousands of times
- Best suited when the project is at the early stages of its development
- Highly reliable since automated tests can contain errors and missed bugs
Q21.What are the drawbacks of manual testing?
De-merits of manual testing are:
- They are highly susceptible to human error and are risky
- Test types like load testing and performance testing are not possible manually
- Regression tests are really time-consuming if they are done manually
- The scope of manual testing is very limited when compared to automation testing
- Not suitable in very large organizations and time-bounded projects
- The cost adds up, so it’s more expensive to test manually in the long run
Q22. What’s the role of documentation in Manual Testing?
Documenting the test cases will help you to estimate the testing effort you will need along with test coverage and tracking and tracing requirements. Some commonly applied documentation artifacts associated with software testing are:
- Test Plan
- Test Scenario
- Test Case
- Traceability Matrix
Q23. Explain What SDLC is.
SDLC is a methodology followed within the software organization to build high-quality software at low cost. It does the planning of what the software has to perform, then designing how it will work, and creating it. Thereafter, there are tests executed on the software to ensure everything is in place. Once everything checks out, the system is ready to be deployed for people to use. Even after the release, a developer continues maintenance or an update of his software in order to run it smoothly and further develop features. It may turn into a properly structured process—one seeing reliability and consistency in serving user interests regarding software.
Q24. What is a test case?
A test case may be defined as a well-documented set of steps or actions that a tester executes in order to validate whether some features or functions of the software application are working correctly according to heterogeneous specified requirements. Normally, each test case will contain the following:
- Test Case ID: It provides a unique identity to the test case.
- Description: This is a small note describing what a test case is aimed at testing.
- Preconditions: These can be thought of as the special conditions that need to be satisfied before running the test case.
- Steps: What is the sequence of steps to execute the test?
- Expected Result: What type of outcome or behavior do we expect when these test steps are run?
- Actual Result: What actually has been seen when the test was run?
- Status: Pass, Fail or other problems.
- Comments: Test Scenarios or any other additional notes/comments on the operation of tests.
Q25. What is a test plan?
A manual test plan is just like a roadmap for testing a software application. It states what is to be tested, how it will be tested, and who conducts the testing. One can think of it as a very Elaborate checklist that helps rigorously check all of the Various aspects of software before its release. This helps a tester keep himself organized, ensure that nothing major is missed, and provide a clear structure to testing activities.
Q26. What is test data?
Test data refers to the input used to test the software application under test. It may include specified values, scenarios, or examples against which an attempt is made to prove whether the software really works perfectly under a diversity of conditions.
Q27. What is Sanity testing?
It involves rapid and concentrated testing to verify whether the most important functionalities of a software application still work as expected after some minor changes or fixes of the bugs. Sanity testing is actually meant to see if the system is stable; it does not concern itself with the large impacts made by the introduced changes.
Q28. When should developers implement configuration management procedures?
Configuration management procedures should be established from an early phase of development to record changes, manage software versions, and provide uniqueness in deployment and collaboration.
Q29. List the four different test levels
The four different types of tests are:
- Functional Testing
- Regression Testing
- Usability Testing
- Integration Testing
Q30. What about the difference between an error and a failure?
Whereas an error refers to a defect in the software code, failure is observable and is the result of tested software failing to meet expectations.
Advanced Level Manual Testing Interview Questions
Q32. What is the difference between manual testing and automation testing?
Manual Testing | Automation Testing |
In manual testing, the accuracy and reliability of test cases are low, as manual tests are more prone to human error. | Automated testing, on the other hand, is more reliable as tools and scripts are used to perform tests. |
The time required for manual testing is high as human resources perform all the tasks. | The time required is comparatively low as software tools execute the tests |
In manual testing, investment cost is low, but return on investment (ROI) is low as well. | In automation testing, investment cost and Return on Investment are both high. |
Manual testing is preferred when the test cases are run once or twice. It is also suitable for Exploratory, Usability, and ad hoc testing. | You can use test automation for Regression Testing, Performance Testing, Load Testing or highly repeatable functional test cases |
Allows for human observation to find out any glitches. Therefore, manual testing helps in improving the customer experience. | As there is no human observation involved, there is no guarantee of a positive customer experience. |
Alternatively, you can check out the Automation Engineer Course by Edureka and get certified!
Q33. When should you opt for manual testing over automation testing?
There are a lot of cases when manual testing is better suited over automation testing, like:
- Short-time projects: Automated tests aim to save time and resources, yet they require time and resources to design and maintain. For example, if you are building a small promotional website, it can be much more efficient to rely on manual testing.
- Ad-hoc Testing: Ad-hoc testing has no specific approach. It is a totally unplanned method of testing in which the tester’s understanding and insight are the only important factors. This can be achieved using manual testing.
- Exploratory Test: This type of testing requires the tester’s knowledge, experience, analytical and logical skills, creativity, and intuition. Therefore, human involvement is important in exploratory testing.
- Usability Testing: When performing usability testing, the tester needs to measure how user-friendly, efficient, or convenient the software or product is for the end-users. Human observation is the most important factor, so manual testing sounds seem more appropriate.
Q34. What are the phases involved in the Software Testing Life Cycle?
The different phases involved in the software testing life cycle are:
| Phases | Explanation |
| Requirement Analysis | QA team understands the requirement in terms of what we will testing & figure out the testable requirements. |
| Test Planning | In this phase, the test strategy is defined. Objective & the scope of the project is determined. |
| Test Case Development | Here, detailed test cases are defined and developed. The testing team also prepares the test data for testing. |
| Test Environment Setup | It is a setup of software and hardware for the testing teams to execute test cases. |
| Test Execution | It is the process of executing the code and comparing the expected and actual results. |
| Test Cycle Closure | It involves calling out the testing team member meeting & evaluating cycle completion criteria based on test coverage, quality, cost, time, critical business objectives, and software. |
If you face any challenges with these Manual Testing interview questions, please leave a comment on your problems.
Q35. What is the difference between a bug, a defect and an error?
Bug – A bug is a fault in the software that’s detected during testing time. They occur because of some coding error and leads a program to malfunction. They may also lead to a functional issue in the product. These are fatal errors that could block a functionality, results in a crash, or cause performance bottlenecks
Defect—A defect is a variance between expected results and actual results detected by the developer after the product goes live. It is an error found AFTER the application goes into production. In simple terms, it refers to several troubles with the software product, its external behavior, or its internal features.
Error—An error is a mistake, misunderstanding, or misconception on the part of a software developer. Developers include software engineers, programmers, analysts, and testers. For example, a developer may misunderstand a design notation, or a programmer might type a variable name incorrectly—both lead to errors. An error normally arises in software and changes the program’s functionality.
You can even check out the details of Manual Testing with the Manual Testing course.
Q36. What makes a good test engineer?
A software test engineer is a professional who determines how to create a process for testing a particular product in the software industry.
- A good test engineer should have a ‘test to break’ attitude, an ability to take the point of view of the customer
- Strong desire for quality and attention to minute details
- Tact and diplomacy to maintain a cooperative relationship with developers
- Ability to communicate with both technical (developers) and non-technical (customers, management) people
- Prior experience in the software development industry is always a plus
- Ability to judge the situations and make important decisions to test high-risk areas of an application when time is limited
Q37.What is regression testing? When to apply it?
“Testing of a previously tested program to ensure that defects have not been introduced or uncovered in unchanged areas of the software, as a result of the changes made is called Regression Testing.”
A regression test is a system-wide test whose main purpose is to ensure that a small change in one part of the system does not break existing functionality elsewhere in the system. It is recommended to perform regression testing on the occurrence of the following events:
- When new functionalities are added
- In case of change requirements
- When there is a defect, fix.
- When there are performance issues
- In case of environmental changes
- When there is a patch fix
Related Learning: Performance Testing Interview Questions
Q38. What is the difference between system testing and integration testing?
| System Testing | Integration Testing |
System Testing tests the software application as a whole to check if the system is compliant with the user’s requirements | Integration testing tests the interface between modules of the software application |
Involves both functional and non-functional tests like sanity, usability, performance, stress, an load | Only functional testing is performed to check whether the two modules, when combined, give the right outcome |
It is high-level testing performed after integration testing | It is low-level testing performed after unit testing |
Q39. Explain the defect life cycle.
A defect life cycle is a process in which a defect goes through various phases during its whole lifetime. The cycle starts when a defect is found and ends when a defect is closed after ensuring it’s not reproduced. The bug or defect life cycle includes the steps shown in the figure below.
If you wish to learn in-depth about Bug Life Cycle then you can refer this article on Software Testing Tutorial.
Q40. What is the test harness?
A test harness is the gathering of software and test information arranged to test a program unit by running it under changing conditions like stress, load, data-driven, and monitoring its behavior and outputs. Test Harness contains two main parts:
– A Test Execution Engine
– Test script repository
Q41. What is test closure?
Test Closure is a document that summarizes all the tests conducted during the software development life cycle and provides a detailed analysis of the bugs removed and errors found. This memo contains the aggregate number of experiments, total number of experiments executed, total number of imperfections discovered, total number of imperfections settled, total number of bugs not settled, total number of bugs rejected, and so forth.
Q42. What is the difference between Positive and Negative Testing?
Positive Testing | Negative Testing |
Positive testing determines that your application works as expected. If an error is encountered during positive testing, the test fails | Negative testing ensures that your application can gracefully handle invalid input or unexpected user behavior |
In this testing, the tester always checks for an only a valid set of values | Testers apply as much creativity as possible and validate the application against invalid data |
Q43. What is your approach towards a severely buggy program? How would you handle it?
When dealing with a severely buggy program, a systematic approach is essential to identify, prioritize, and resolve the issues effectively. Here’s how I would handle it:
Bug Triage: Start by categorizing and prioritizing the bugs based on their severity and impact on the program’s functionality. Critical bugs affecting core functionalities should be addressed first.
Isolate and Reproduce: Reproduce the bugs in a controlled environment to understand their triggers and conditions. Isolating the bugs helps in diagnosing the root causes.
Root Cause Analysis: Conduct a thorough investigation to identify the root causes of the bugs. This may involve reviewing the code, logs, and system behavior to pinpoint the areas requiring correction.
Fix the Bugs: Develop patches or fixes to address the identified issues. Implement solutions that not only resolve the immediate problems but also consider the potential implications on other parts of the program.
Unit Testing: Roughly test the individual fixes through unit testing to ensure that they don’t introduce new problems or regressions.
Q44. What is the pesticide paradox? How to overcome it?
According to the pesticide paradox, if the same tests are repeated over and over again, eventually, the same test cases will no longer find new bugs. Developers will be extra careful in those places where testers found more defects and might not look into other areas. Methods to prevent pesticide paradox:
- To write a whole new set of test cases to exercise different parts of the software.
- To prepare new test cases and add them to the existing test cases.
Using these methods, it’s possible to find more defects in the area where defect numbers dropped.
Q45. What is Defect Cascading in Software Testing?
Defect Cascading is the process of triggering other defects in the application. When a defect goes unnoticed while testing, it invokes other defects. As a result, multiple defects crop up in the later stages of development. If defect cascading continues to affect other features in the application, identifying the affected feature becomes challenging. You may make different test cases to solve this issue, even then it is difficult and time-consuming.
Q46. What is the term ‘quality’ mean when testing?
In general, quality software is reasonably bug-free, delivered on time and within budget, meets requirements and/or expectations, and is maintainable. But again ‘quality’ is a subjective term. It will depend on who the ‘customer’ is and their overall influence in the scheme of things. For example, each type of ‘customer’ will have their own slant on ‘quality’ – the accounting department might define quality in terms of profits while an end-user might define quality as user-friendly and bug-free.
Q47. What is black box testing, and what are the various techniques?
Black-Box Testing, also known as specification-based testing, analyses the functionality of a software/application without knowing much about the internal structure/design of the item. The purpose of this testing is to check the system’s functionality as a whole to ensure that it works correctly and meets user demands. Various black-box testing techniques are:
- Equivalence Partitioning
- Boundary Value Analysis
- Decision Table Based Technique
- Cause-effect Graphing
- Use Case Testing
Q48. What is white box testing, and what are the various techniques?
White-Box Testing, also known as structure-based testing, requires a profound knowledge of the code as it includes testing of some structural part of the application. The purpose of this testing is to enhance security, check the flow of inputs/outputs through the application, and improve design and usability. Various white-box testing techniques are:
- Statement Coverage
- Decision Coverage
- Condition Coverage
- Multiple Condition Coverage
Q49. What are the Experience-based testing techniques?
Experienced-based testing is all about discovery, investigation, and learning. The tester constantly studies and analyzes the product and accordingly applies his skills, traits, and experience to develop test strategies and test cases to perform necessary testing. Various experience-based testing techniques are:
- Exploratory Testing
- Error Guessing
Q50. What is a top-down and bottom-up approach in testing?
Top-Down—Testing happens from top to bottom. That is, high-level modules are tested first, followed by low-level modules. Lastly, the low-level modules are incorporated into a high-level state to guarantee the framework is working as it is expected to.
Bottom-Up—Testing happens from base levels to high-up levels. The lowest-level modules are tested first, followed by high-level state modules. Lastly, the high-level state modules are coordinated to a low level to guarantee the framework is filling in as it has been proposed to.
Q51. What is the difference between smoke testing and sanity testing?
| Features | Smoke Testing | Sanity Testing |
|---|---|---|
System Builds | Tests are executed on initial builds of software product | Tests are done on builds that have passed smoke tests & rounds of regression tests |
Motive of Testing | To measure the stability of the newly created build to face off more rigorous testing | To evaluate rationality & originality of the functionalities of software builds |
Subset of? | Is a subset of acceptance testing | Is a subset of regression testing |
Documentation | Involves documentation and scripting work | Doesn’t emphasize any sort of documentation |
Test Coverage | Shallow & wide approach to include all the major functionalities without going too deep | Narrow & deep approach involving detailed testing of functionalities and features |
Performed By? | Executed by developers or testers | Executed by testers |
Q52. What is the difference between static testing and dynamic testing?
| Static Testing | Dynamic Testing |
Static Testing is a white box testing technique. It includes exploring the records to recognize imperfections in the very early stages of SDLC. | Dynamic testing includes executing code and is done at a later stage of the software development lifecycle. It validates and approves the output with the expected results. |
Static Testing is implemented at the verification stage. | Dynamic testing starts during the validation stage. |
Static testing is performed before the code deployment. | Dynamic testing is performed after the code deployment |
The program’s code error detection and execution is not a concern in this type of testing. | Execution of code is necessary for dynamic testing. |
Q53. Explain Functional Testing
Functional testing is a black-box testing technique in which a system’s selected functionality is validated for return with expected outputs upon certain inputs of criteria.
This means ensuring that the application does what it is supposed to do, works correctly against specifications, and yields the expected business functionalities. This form of testing tends to focus on what the software does and how well it performs, and in most cases, is not concerned with internal structures or code.
Types of functional testing are:
1. Unit Testing
2. Integration Testing
3. System Testing
4. Acceptance Testing
5. Smoke Testing
6. Regression Testing
7. Interface Testing
8. Usability Testing
9. Localization Testing
Q54. Explain non-functional testing
Non-functional testing deals with checking parameters relating to a software system’s performance, security, usability, compatibility, reliability, and maintainability. It is conducted to ensure that the software produces correct results but is not just correct; rather, it is efficient, secure, and effective in its execution across different environments and variable conditions.
If tested well under non-functional testing, such attributes can significantly reduce the associated risks while increasing system quality and user experience, thereby helping to make a software product successful and reliable.
Q55. Mention few advantages of automated testing
- Automated testing offers several advantages:
- Speed: Tests can be run more quickly than manual testing.
- Accuracy: Automation minimizes human errors in test execution.
- Repeatability: Tests can go consistently and repeatedly, too.
- Coverage: It facilitates wider coverage of tests on different scenarios.
- Efficiency: Automated tests save time and efforts in comparison with manual testing.
Q56. What is a critical Bug?
Critical bugs are the most serious problems existing around a software package since they cause system crashes, engender data loss, make software interoperability, or have some critical impact on some key functionality. This has, in interesting ways, called for more attention by the developer under view to fix so as to prevent serious consequences for the user or operations. Critical bugs are prioritized for resolution to ensure the stability and reliability of the software as soon as possible.
Q57. What is API testing?
API testing can be defined as a process to validate APIs’ functionality, performance, and standards. APIs denote a set of application programming interfaces used by software applications for integration and communication.
Q58. What is System testing?
System testing is the phase of testing where this system is tested as an integrated, complete system for general functionality, performance, reliability, and usability. This phase tests whether all the components work together as expected, with the simple aim of validating them against system requirements so that they will work according to expectations in different scenarios before their release or deployment.
Q59. What do you mean by Defect Triage?
Basically, defect triage is used to determine how bad every defect or problem reported is in software development. Each one is then judged against criteria like the extent of functional impact, frequency of occurrence, and possible project risks.
In triaging, a group of developers, testers, product managers, and stakeholders usually reviews each defect and discusses it before setting its priority for resolution. This ensures that any critical issues are dealt with immediately, thus providing a correct overall quality and progress calibration in the software development lifecycle.
Q60. What is Integration Testing? What are its types?
Integration testing is when units or individual components of a software system are combined and tested as one.
The following are the types of integration testing:
- Big Bang Integration Testing: Here, modules are all integrated in a single go only for the purpose of testing the entire system and observing the integration issues.
Top-Down Integration Testing: The testing here starts from all the top level modules. The addition of lower modules follows progressively with the help of stubs. - Bottom-Up Integration Testing: This starts integrating the components from the lower-level modules. The direction of integration is from bottom to highest level, facilitated by the creation of drivers that simulate behavior for the higher-level modules.
- Sandwich Integration Test: This technique is a hybrid of above and below. Here the integration of modules depends upon the relation and complexity of the modules w.r.t. each other.
- Incremental Integration Testing: The test methodology that is going to be undertaken is incremental module integration until the whole system. Such testing shall help Nights find the integration problems early in the cycle of development.
Q61. What is a stub?
A stub is a thinned or reduced implementation of a software module that imitates a real component; it provides basic functionality with predefined responses, simulating the interaction in the absence of an actual component or when such a component might not be fully implemented.
Q62. What is code coverage?
Code coverage is among the measures used for software testing and hence shows the amount of source code of a program that would be run during testing. More precisely, this will be expressed as a percentage form of source lines of code, branches, statements, or conditions in the software testing code base exercised by test cases.
Q63. When can you say for sure that the code has met its specifications?
You can confidently say that when code passes every test case, functional or not, it has gone through all the acceptance criteria with no showstoppers at all, or major deviations; because of this, it has met its specifications.
Q64. Explain equivalence class partitioning
The equivalence partitioning technique divides input data into partitions with similar expected output for each partition. This technique reduces redundancy between test cases but still retains all the influential test cases to cover them.
We have completed the theory questions. In the next part of this Manual Testing Interview Questions article, let’s discuss some real-world scenario-based questions.
Real-World Based Manual Testing Interview Questions
Q65. How will you determine when to stop testing?
Deciding when to stop testing can be quite difficult. Many modern software applications are so complex and run in such an interdependent environment that complete testing can never be done. Some common factors in deciding when to stop testing are:
- Deadlines (release deadlines, testing deadlines, etc.)
- Test cases completed with certain percentage passed
- When the test budget is depleted
- Coverage of code or functionality or requirements reaches a specified point
- Bug rate falls below a certain level
- When Beta or alpha testing period ends
Q66. What if the software is so buggy it can’t really be tested at all?
Often testers encounter a bug that can’t be resolved at all. In such situations, the best bet is for testers to go through the process of reporting whatever bugs or blocking-type problems initially show up, with the focus being on critical bugs. Since this type of problem can cause severe problems such as insufficient unit testing or insufficient integration testing, poor design, improper build or release procedures, etc managers should be notified and provided with some documentation as evidence of the problem.
Q67. How you test a product if the requirements are yet to freeze?
It’s possible that a requirement stack is not available for a piece of product. It might take serious effort to determine if an application has significant unexpected functionality, and it would indicate deeper problems in the software development process. If the functionality isn’t necessary to the purpose of the application, it should be removed. Else, create a test plan based on the assumptions made about the product. But make sure you document all assumptions well in the test plan.
Q68. What if an organization is growing so fast that fixed testing processes are impossible? What to do in such situations?
This is a very common problem in the software industry, especially considering the new technologies that are being incorporated when developing the product. There is no easy solution in this situation, you could:
• Hire good and skilled people
• Management should ‘ruthlessly prioritize’ quality issues and maintain focus on the customer
• Everyone in the organization should be clear on what ‘quality’ means to the end-user
Q69. What is a cause-effect graph?
A cause-effect graph, also known as a cause-and-effect diagram or Ishikawa diagram, is a visual tool for problem-solving and root-cause analysis. Japanese quality control expert Kaoru Ishikawa developed it, which is often referred to as the “fishbone diagram” due to its resemblance to a fish skeleton.
The diagram helps identify and explore the potential causes leading to a particular problem or effect. It’s particularly useful in understanding the complex relationships between various factors that contribute to an issue. The main components of a cause-effect graph include:
1. Effect: The problem or issue you’re trying to address is placed at the head of the diagram.
2. Major Causes: These are the main categories of factors that could contribute to the problem. They are typically categorized into branches stemming from the main horizontal line (the “spine” of the fishbone).
3. Sub-causes: Each major cause is further broken down into sub-causes or specific factors that could be contributing to the problem. These are detailed within the branches of the diagram.
Q70. What are the cases when you’ll consider choosing automated testing over manual testing?
Automated testing can be considered over manual testing during the following situations:
- When tests require periodic execution
- Tests include repetitive steps
- Tests need to be executed in a standard runtime environment
- When you have less time to complete the testing phase
- When there is a lot of code that needs to be repeatedly tested
- Reports are required for every execution
Q71. What is ‘configuration management’?
Every high-functioning organization has a “master plan” that details how they are supposed to operate and accomplish tasks. Software development and testing are no different. Software configuration management (SCM) is a set of processes, policies, and tools that organize, control, coordinate, and track:
- code
- documentation
- problems
- change requests
- designs and tools
- compilers and libraries
Q72. Is it true that we can do system testing at any stage?
In system testing, all the software components are tested as a whole to ensure that the overall product meets the specified requirements. So, no. System testing must start only if all units are in place and working properly. System testing usually happens before the UAT (User Acceptance Testing).
Q73. What are some best practices that you should follow when writing test cases?
A few guidelines that you need to follow while writing test cases are:
- Prioritize which test cases to write based on the project timelines and the risk factors of your application.
- Remember the 80/20 rule. To achieve the best coverage, 20% of your tests should cover 80% of your application.
- Don’t try to test cases in one attempt instead improvise them as you progress.
- List down your test cases and classify them based on business scenarios and functionality.
- Make sure test cases are modular and test case steps are as granular as possible.
- Write test cases in such a way that others can understand them easily & modify if required.
- Always keep end-users’ requirements in the back of your mind because ultimately, the software designed is for the customer
- Actively use a test management tool to manage a stable release cycle.
- Monitor your test cases regularly. Write unique test cases and remove irrelevant & duplicate test cases.
Q74. Why is it that the boundary value analysis provides good test cases?
Boundary value analysis provides good test cases because a greater number of errors usually occur at the boundaries rather than in the center of the input domain for a test.
In the boundary value analysis technique, test cases are designed to include values at the boundaries. If the input is within the boundary value, it is considered ‘Positive testing.’ If the input is outside of the boundary value, it is considered ‘Negative testing.’ It includes maximum, minimum, inside or outside edge, typical values, or error values.
Let’s suppose you are testing for an input box that accepts numbers from ’01 to 10′.
Using the boundary value analysis we can define three classes of test cases:
- Test cases with test data exactly as the input boundaries of input: 1 and 10 (in this case)
- Values just below the extreme edges of input domains: 0 and 9
- Test data with values just above the extreme edges of input domains: 2 and 11
So the boundary values would be 0, 1, 2 and 9, 10, 11.
Q75.Why is it impossible to test a program thoroughly or 100% bug-free?
It is impossible to build a software product that is 100% bug-free. You can just minimize the error, flaw, failure, or fault in a computer program or system that causes it to produce an incorrect or unexpected result.
Here are the two principal reasons that make it impossible to test a program entirely.
- Software specifications can be subjective and can lead to different interpretations.
- A software program might require too many inputs, outputs, and path combinations to test.
Q76. Can automation testing replace manual testing?
Automation testing isn’t a replacement for manual testing. No matter how good automated tests are, you cannot automate everything. Manual tests play an important role in software development and come in handy whenever you have a case where you cannot use automation. Automated and manual testing each have their own strengths and weaknesses. Manual testing helps us understand the entire problem and more flexibly explore other angles of tests. On the other hand, automated testing helps save time in the long run by accomplishing a large number of surface-level tests in a short time.
That’s it, folks! We have reached the end of this ‘Manual Testing Interview Questions.’ You could also look at Automation Testing Interview Questions while you’re at it.
FAQs
1. How do I prepare for a manual test interview?
One needs to know the underlying test concepts—types of tests, testing methodologies like Agile and Waterfall, and software development cycles. Practice writing test cases, executing them, and report bugs. Standard manual testing tools should be at your fingertips. Be prepared to discuss problem-solving, team player skills, and experience with testing challenges. Stay current on trends and creativity in the area of software testing to demonstrate how well you can prepare for the job role.
2. What are the important questions in manual testing?
Here are some important questions in manual testing:
- What are the different types of testing?
- How do you create and prioritize test cases?
- How do you identify and report defects?
- What has been your exposure to the testing methodologies such as Agile and Waterfall?
- Which testing tools or systems have you worked with?
- How did you communicate with the stakeholders during the testing process?
- Can you tell me about a real testing situation that posed difficulties to you?
- How will you keep yourself updated regarding what is happening in industries on testing?
3. What is manual testing in an interview?
Basically, manual testing refers to the process whereby test cases are executed one after another. Manual testing is the running of software functionality to test its quality, look for its defects, check confirmation of the software used to meet the specified requirements, or even conduct an interview.
4. What are the skills for manual testing?
Skills for manual testing include:
- Understanding testing fundamentals and methodologies.
- Creating and executing test cases.
- Identifying and reporting defects.
- Attention to detail and critical thinking.
- Communication and teamwork.
5. Are manual testing interviews easy?
The level of difficulty of a manual testing interview would depend on the company and the applied role expectation. A candidate should, therefore, be prepared with respect to the fundamentals, methodologies, and practical skills in testing so that he or she can handle such interviews.
If you found this article relevant, check out the Selenium Certification course by Edureka, a trusted online learning company with a network of more than 250,000 satisfied learners worldwide.
Do you have a question for us? Please mention it in the comments section and we will respond to you.