Manual testing is a fundamental pillar of quality assurance in software development. Whether you’re a fresher stepping into the QA field or an experienced professional looking to sharpen your skills, mastering manual testing concepts is essential for interview success. This comprehensive guide covers 30 carefully selected interview questions progressing from basic to advanced levels, designed to help you confidently tackle any manual testing interview.
Basic Level Questions (Freshers)
1. What is manual testing and why is it needed in software development?
Manual testing is the process of manually executing test cases without using automation tools. A tester physically interacts with the application to identify defects and verify that the software meets specified requirements.
Manual testing is needed because:
- It is ideal for testing new features that require initial validation before automation
- It excels at identifying user interface (UI) and accessibility issues that automated tests might miss
- It allows testers to perform exploratory testing and ad-hoc testing scenarios
- It requires minimal setup and configuration compared to automated testing
- It leverages human judgment to understand user experience and usability concerns
2. Explain the Software Development Life Cycle (SDLC) and the Software Testing Life Cycle (STLC).
SDLC is the overall process for developing software and includes requirement gathering, system design, coding and implementation, quality validation through testing, deployment to production, and ongoing maintenance.
STLC is specifically focused on testing activities and involves these phases:
- Requirement analysis
- Test planning
- Test case design
- Test environment setup
- Test execution
- Test closure
3. What is the difference between verification and validation?
Verification is the process of checking whether the software conforms to specifications. It answers the question “Are we building the product right?” This includes reviewing written code for compliance with project specifications.
Validation is the process of evaluating whether the software meets the actual business needs and requirements. It answers the question “Are we building the right product?” This involves testing the final product against user requirements.
4. What are test cases and how do you write an effective test case?
A test case is a set of conditions or variables under which a tester will determine if an application or software system is working as expected. An effective test case includes:
- Test case ID (unique identifier)
- Test scenario description
- Prerequisites and test data
- Step-by-step execution steps
- Expected results
- Actual results (recorded after execution)
- Pass/Fail status
5. What is black-box testing and white-box testing?
Black-box testing is testing without knowledge of internal code structure. The tester focuses on inputs and outputs to verify that the application behaves as specified. This is the primary approach in manual testing.
White-box testing requires knowledge of the internal code structure and logic. Testers examine code paths, logic, and internal operations to identify defects. This typically requires technical expertise and is often combined with code reviews.
6. What are test scenarios and how do they differ from test cases?
Test scenarios are high-level descriptions of what to test. They represent user journeys or business processes. For example: “Test the login functionality with valid and invalid credentials.”
Test cases are detailed, step-by-step instructions derived from scenarios. A single scenario can generate multiple test cases. For the login scenario above, you might have separate test cases for valid username/password, invalid username, invalid password, and empty fields.
7. Explain the roles and responsibilities of a manual tester.
Manual testers have diverse responsibilities that include:
- Analyzing client requirements and project specifications
- Reviewing written code for compliance with project specifications
- Creating and maintaining test environments for executing test cases
- Designing comprehensive test cases and test scenarios
- Executing test cases and comparing actual results with expected results
- Detecting, documenting, and reporting bugs with detailed information
- Monitoring system errors and discussing them with development teams
- Organizing and conducting review meetings
- Coordinating with test managers and stakeholders
8. What skills are required to become a successful manual tester?
Essential manual testing skills include:
- Strong analytical and logical thinking abilities
- Attention to detail and ability to report test results professionally
- Knowledge of SDLC and STLC methodologies
- Understanding of SQL and database concepts
- Familiarity with Agile methodologies and frameworks
- Ability to plan, track, and manage the testing process
- Knowledge of test management tools and test tracking tools
- Understanding of various testing techniques and approaches
- Ability to perform technical testing when required
- Strong communication and documentation skills
9. What is a test plan and what should it include?
A test plan is a comprehensive document that outlines the testing approach, objectives, scope, and strategies. A well-structured test plan should include:
- Testing objectives and goals
- Scope of testing (what will and will not be tested)
- Testing methodologies and techniques to be used
- Test environment requirements
- Test schedule and timelines
- Resource allocation and team responsibilities
- Test deliverables and reporting standards
- Entry and exit criteria
- Risk assessment and mitigation strategies
- Tools and technologies required
10. Explain the bug life cycle in manual testing.
The bug life cycle describes the stages a defect goes through from discovery to closure:
- New: Bug is newly discovered and documented
- Assigned: Bug is assigned to a developer
- In Progress: Developer is working on fixing the bug
- Fixed: Developer has completed the fix
- Closed: Tester verifies the fix and closes the bug
- Reopened: If the fix doesn’t resolve the issue, the bug is reopened
- Deferred: Bug is postponed to a future release
- Not a Bug: Issue is determined to not be a defect
Intermediate Level Questions (1-3 Years Experience)
11. What is exploratory testing and when should it be used?
Exploratory testing is an informal testing approach where testers simultaneously learn about the application, design tests, and execute them without predefined test cases. Testers use their experience and intuition to explore the application’s functionality.
Exploratory testing should be used:
- When requirements are unclear or incomplete
- When testing new features or unfamiliar applications
- To complement formal test case execution
- When there is limited time for comprehensive test case documentation
- To discover unexpected issues and edge cases
12. Differentiate between functional testing and non-functional testing.
Functional testing verifies that the application functions according to specified requirements. It tests what the system does, including features, user workflows, and business logic. Examples include testing login functionality, payment processing, and data validation.
Non-functional testing evaluates how well the system performs. It tests attributes like performance, security, reliability, scalability, and usability. Examples include load testing, stress testing, security testing, and compatibility testing.
13. What is test data and why is it important?
Test data is the input data used during test execution to validate that the software behaves correctly under various conditions. Test data can include positive data (valid inputs), negative data (invalid inputs), and boundary data (edge cases).
Test data is important because:
- It ensures comprehensive coverage of different scenarios
- It helps identify how the application handles invalid inputs
- It allows testing of edge cases and boundary conditions
- It enables reproduction of real-world user scenarios
- It helps uncover hidden defects and vulnerabilities
14. What is the manual testing process step by step?
The manual testing process follows these key steps:
- Identify the scope of testing: Determine what functionality will be tested, ranging from individual features to end-to-end systems
- Design test cases: Create comprehensive test cases including test scenarios, test data, expected results, and execution steps
- Execute test cases: Manually run test cases and compare actual results with expected results to identify discrepancies
- Record results: Document all test execution results for further analysis and reporting
- Report defects: Log any identified bugs with detailed information including steps to reproduce and severity level
- Verify fixes: Retest fixed defects to ensure they have been properly resolved
15. How should test cases be prioritized and organized?
Test cases should be prioritized and organized using these best practices:
- Prioritize based on risk: Focus on test cases that cover high-risk areas and critical functionalities first
- Consider business impact: Prioritize features that directly impact business operations and user experience
- Follow the 80/20 rule: Ensure that 20% of test cases cover 80% of the application functionality
- Categorize by business scenarios: Group test cases according to business workflows and functionality
- Design modular test cases: Create independent, detailed test cases that are easy to maintain and update
- Remove duplicates: Eliminate irrelevant and duplicate test cases to optimize testing efforts
16. What is test closure and what activities are involved?
Test closure is the final phase of the testing life cycle where testing activities are wrapped up. Key closure activities include:
- Evaluating whether testing objectives have been achieved
- Reviewing all test results and coverage metrics
- Analyzing defect data and trends
- Documenting lessons learned and recommendations
- Archiving test cases and test data for future reference
- Generating final test reports for stakeholders
- Conducting a post-testing review meeting
17. Describe how you would test a new feature for a Google-like search application.
To test a new search feature, I would follow this comprehensive approach:
Requirement Analysis: First, I would thoroughly review the feature specifications and understand exactly what the search feature should accomplish, including performance expectations and user requirements.
Test Planning: I would create a detailed test plan outlining the testing approach, methodologies, test cases, and expected results. I would identify the test environment requirements and resource needs.
Test Case Design: I would design comprehensive test cases covering:
- Valid search queries (single word, multiple words, special characters)
- Empty search queries
- Very long search queries
- Search with different languages and character sets
- Filtering and sorting of search results
- Pagination of search results
- Relevance of returned results
- Search auto-complete or suggestions functionality
- Performance with large result sets
Test Execution: I would execute all test cases, document actual results, and identify any discrepancies from expected behavior.
Defect Reporting: For any issues found, I would document them with detailed steps to reproduce, severity level, and attach screenshots where applicable.
Verification: After fixes are applied, I would retest the affected areas to confirm proper resolution.
18. How would you approach testing a payment gateway integration?
Testing a payment gateway integration requires careful planning and attention to security and functionality:
Requirements Review: Understand the payment methods supported, currency support, transaction limits, and error handling requirements.
Test Environment Setup: Ensure access to a secure test environment with test payment credentials and sandbox accounts provided by the payment gateway.
Functional Testing: Test all payment scenarios including successful transactions, declined payments, timeout handling, and various payment methods (credit card, debit card, digital wallets).
Data Validation: Verify that all payment data is captured correctly, including amount, currency, merchant details, and transaction reference numbers.
Error Handling: Test how the system handles various error scenarios such as invalid card numbers, expired cards, insufficient funds, and network failures.
Security Testing: Ensure sensitive payment information is not logged or displayed inappropriately. Verify SSL/TLS encryption is properly implemented.
Integration Testing: Verify that payment status updates are correctly reflected in the order management system and that customers receive proper confirmation.
Boundary Testing: Test edge cases such as minimum and maximum transaction amounts, invalid currency codes, and special characters in payment information.
19. What is the difference between a defect, bug, error, and failure?
Error: A human mistake or misconception during software development, such as incorrect logic in code.
Bug (or Defect): The result of an error in the code that causes incorrect behavior. It is what a tester finds during testing.
Failure: The inability of the software to perform its intended function. A failure occurs when a bug is executed during testing or in production.
Defect: A general term for any problem found during testing that deviates from the expected behavior, including bugs, missing features, or usability issues.
20. How would you handle testing when requirements are vague or incomplete?
When dealing with unclear requirements, I would take the following approach:
- Schedule a clarification meeting with stakeholders, business analysts, and product owners to understand the intended functionality
- Document assumptions I make about the feature based on available information
- Use exploratory testing to discover the actual behavior and user workflows
- Create baseline test cases based on the most likely interpretation of requirements
- Perform ad-hoc testing to identify potential issues and edge cases
- Communicate findings and assumptions back to the team for validation
- Update test cases as requirements are clarified and refined
Advanced Level Questions (3+ Years Experience)
21. Explain how you would estimate testing effort and timeline for a complex project.
Estimating testing effort requires analyzing multiple factors:
Key Estimation Factors:
- Complexity of requirements and feature interactions
- Total number of test cases required for adequate coverage
- Readiness and stability of the test environment
- Availability of resources with required expertise
- Risk assessment and areas requiring focused testing
- Defect density patterns from similar past projects
- Integration points with external systems
- Performance and non-functional testing requirements
- Regression testing scope for existing features
Estimation Process:
- Break down testing into specific activities (test design, execution, defect verification)
- Estimate hours required for each activity based on historical data
- Apply contingency buffers for unexpected issues (typically 15-20%)
- Account for rework and retesting cycles
- Factor in knowledge gaps and team learning curve
22. How do you manage testing in an Agile development environment?
Testing in Agile requires a different mindset and approach compared to traditional waterfall projects:
Sprint-Based Testing: Testing activities are integrated within each sprint alongside development. Tests begin as soon as code is available, allowing for continuous feedback.
Continuous Communication: Daily standups include testing updates. Testers collaborate closely with developers and product owners to clarify requirements immediately.
Flexible Test Design: Test cases are designed and refined incrementally as features are developed, rather than all at once at the beginning.
Automation Support: Manual testing is complemented by automated tests for regression, allowing testers to focus on new feature validation and exploratory testing.
Definition of Done: Testing is part of the definition of done for each user story. Features are not considered complete until they pass manual testing.
Continuous Integration: Testers work within continuous integration pipelines, testing each build to catch regressions early.
Adaptive Planning: Test plans are adjusted based on discovered issues and changing priorities within the sprint.
23. Describe your approach to testing a critical production issue reported by a Paytm-like fintech customer.
Managing critical production issues requires a structured, methodical approach:
Immediate Response: Upon receiving the critical issue report, I would immediately gather all relevant information: what functionality is affected, how many users are impacted, what is the business impact, and when did the issue first occur.
Issue Isolation: I would attempt to reproduce the issue in the production environment (if possible under controlled conditions) and also in the test environment to understand the exact conditions triggering the failure.
Root Cause Analysis: Working with developers, I would help identify the root cause by examining recent code changes, database modifications, or external system dependencies.
Rapid Testing: Once a fix is deployed, I would execute focused test cases covering the specific issue and surrounding functionality to verify the fix and ensure no new issues were introduced.
Regression Verification: I would run critical regression tests on related features to ensure the fix did not break anything else.
Monitoring: After the fix is deployed to production, I would monitor metrics and error logs to confirm the issue is fully resolved.
Documentation: I would document the issue, root cause, testing performed, and lessons learned for future reference.
24. What challenges do you face when testing mobile applications and how do you overcome them?
Device Fragmentation: With countless device models, screen sizes, and OS versions, testing on all combinations is impossible. I prioritize testing on popular devices and OS versions based on user analytics.
Performance Issues: Mobile apps must perform efficiently with limited resources. I test for battery consumption, memory leaks, and performance under poor network conditions.
Network Variability: Real users experience varying network conditions. I simulate different network speeds and test how the app behaves when connectivity drops.
Installation and Permissions: I verify proper permission handling, installation on different device types, and upgrade paths from previous versions.
Platform-Specific Issues: iOS and Android have different behaviors and limitations. I test on both platforms separately to identify platform-specific defects.
Interruptions: Mobile apps must handle interruptions like calls, notifications, and background processes. I test background app refresh, push notifications, and app state management.
25. How would you test a complex order management system for Amazon-like e-commerce platform?
Testing an e-commerce order management system requires comprehensive coverage of multiple interconnected processes:
Order Creation Testing: Test placing orders with various product combinations, quantities, and delivery addresses. Verify inventory deduction and order confirmation generation.
Payment Processing: Test successful payments, failed transactions, partial payments, refunds, and different payment methods.
Order Status Tracking: Verify accurate status updates through each stage: pending, confirmed, packed, shipped, in-transit, and delivered.
Shipping Integration: Test integration with shipping providers, label generation, tracking number updates, and delivery confirmation.
Return and Refund Management: Test return request initiation, approval workflows, refund processing, and restocking of returned items.
Concurrent Order Processing: Test system behavior under high load with multiple simultaneous orders to ensure data integrity and performance.
Data Consistency: Verify that order data remains consistent across all related systems (inventory, accounting, customer service, warehouse).
Edge Cases: Test scenarios like out-of-stock items, address validation failures, payment gateway timeouts, and partial shipments.
Historical Data Integrity: Ensure past orders remain accessible and unaffected by new order processing.
26. Explain how you would approach performance testing as a manual tester.
While performance testing often relies on automation, manual testers play an important role:
Observation Under Load: During load testing, manually observe system behavior to identify performance bottlenecks, UI freezing, or unusual delays.
User Experience Testing: Manually test how the application feels under stress conditions. Measure response times manually and document user-facing performance issues.
Boundary Testing: Test the system with extreme data volumes to identify the point at which performance degrades significantly.
Network Simulation: Manually test application behavior on slow or intermittent network connections using browser developer tools or network simulation software.
Resource Monitoring: Observe CPU usage, memory consumption, and disk I/O during manual testing to identify resource-intensive operations.
Baseline Establishment: Document normal performance metrics to serve as a baseline for identifying performance degradation.
Comparative Testing: Compare performance across different browser versions, devices, or configurations to identify compatibility-related performance issues.
27. How do you ensure quality when testing time-sensitive features like a Flipkart flash sale event?
Testing time-sensitive features requires meticulous planning and execution:
Pre-Event Preparation: Extensively test all sale-related features weeks in advance including discount application, inventory management, timer accuracy, and user notifications.
Comprehensive Scenarios: Test edge cases specific to flash sales: simultaneous user access, inventory exhaustion, price consistency, and promotional code application under concurrent load.
Data Validation: Verify that discounts are applied correctly, inventory is accurately tracked, and order totals are calculated accurately.
Notification Testing: Test that users receive accurate and timely notifications about sale start, stock status, and countdown timers.
Performance Under Peak Load: Test system stability with simulated peak user traffic expected during the flash sale event.
Rollback Planning: Prepare detailed test cases for rollback scenarios in case of critical issues during the live event.
Real-Time Monitoring: Have test cases ready to quickly verify key functionality during the actual event if issues occur.
User Experience Consistency: Ensure the experience is consistent for all users despite high traffic, with no unexpected errors or delays.
28. What is your approach to testing accessibility and usability in manual testing?
Accessibility Testing: Manual testing excels at finding accessibility issues that automated tools miss:
- Verify keyboard navigation works for all interactive elements
- Test screen reader compatibility with JAWS or NVDA software
- Check color contrast ratios for readability by visually impaired users
- Verify alternative text is present for all images
- Test focus indicators are visible when navigating with keyboard
- Verify form labels are associated with input fields
- Test that all functionality is available through the keyboard alone
Usability Testing: As a manual tester, I evaluate how intuitive and user-friendly the application is:
- Assess whether UI elements are logically organized and discoverable
- Evaluate error messages for clarity and helpfulness
- Test common user workflows to identify friction points
- Verify that instructions and help text are clear and adequate
- Assess consistency of UI patterns throughout the application
- Evaluate loading times and visual feedback during user actions
- Test mobile responsiveness and touch-friendly interface design
29. How would you approach testing a new API integration for a Salesforce-like CRM system?
Testing API integrations requires both technical knowledge and methodical validation:
API Specification Review: Thoroughly understand the API documentation, endpoints, request/response formats, authentication mechanisms, and error codes.
Positive Testing: Test all happy path scenarios where valid requests return expected responses with correct data.
Negative Testing: Test with invalid inputs, malformed requests, missing required fields, and invalid authentication to verify proper error handling.
Data Validation: Verify that data is correctly transmitted between systems, transformed appropriately, and persisted accurately in the database.
Error Handling: Test how the system handles various API errors including timeouts, rate limiting, server errors, and network failures.
Data Integrity: Ensure that simultaneous API calls do not create data inconsistencies or race conditions.
Performance Testing: Measure API response times under normal and peak load conditions.
Security Testing: Verify that API endpoints require proper authentication, use HTTPS, and do not expose sensitive information in responses or logs.
End-to-End Testing: Test the complete workflow from triggering the API call through the CRM system to verifying the results in both systems.
30. Describe your experience with test management tools and how you prioritize test case execution in complex projects.
Test management is crucial for organizing and executing large numbers of test cases efficiently:
Test Management Tools: I have experience with tools like TestRail, Zephyr, or Azure Test Plans for organizing test cases, managing test execution, tracking results, and generating metrics.
Prioritization Strategy: In complex projects with hundreds of test cases, I prioritize execution using these criteria:
- Risk-Based Priority: Focus on test cases covering high-risk areas and critical business functions first
- Coverage Strategy: Apply the 80/20 rule—ensure the most important 20% of test cases cover 80% of functionality
- Regression First: Run regression test cases before new feature tests to ensure stability
- Time Constraints: Identify a minimum viable test set that provides acceptable coverage within project timelines
- Defect History: Prioritize test cases that previously found defects or test areas prone to issues
- Dependencies: Execute tests with dependencies first to unblock other test cases
- Smoke Tests: Run critical path tests early to quickly identify blocking issues
Execution Planning: I create phased test execution plans that balance comprehensive coverage with realistic timelines, allowing for defect verification cycles and regression testing.
Metrics and Reporting: I track test execution progress, pass/fail rates, defect density, and test coverage metrics to provide stakeholders with clear visibility into testing status and product readiness.
Conclusion
Manual testing remains a critical skill in modern software development. These 30 interview questions span foundational concepts through advanced real-world scenarios, designed to prepare candidates at any experience level. Success in manual testing interviews comes from understanding core concepts, developing practical problem-solving skills, and staying current with industry practices. Practice articulating your testing approach, ask clarifying questions in interviews, and be ready to discuss specific examples from your experience. Whether you’re just starting your QA career or advancing to senior testing roles, continuous learning and hands-on practice will make you a competitive candidate in the job market.
