Wipro Software Testing Interview Questions and Answers

Microsoft scenario-based software testing interviews are designed to evaluate how candidates apply testing knowledge to real-world situations rather than simply recalling definitions. Interviewers present practical software testing scenarios involving web applications, mobile apps, APIs, databases, and Agile development environments to assess analytical thinking, problem-solving skills, and decision-making abilities. These questions help determine whether a candidate can identify defects, prioritize testing activities, write effective test cases, and communicate findings clearly.For beginners, the interview typically focuses on fundamental testing concepts such as functional testing, regression testing, smoke testing, sanity testing, boundary value analysis, equivalence partitioning, defect lifecycle, test case design, and bug reporting. Candidates may also encounter scenarios related to login functionality, form validation, shopping carts, payment processing, session management, browser compatibility, performance issues, security vulnerabilities, and user interface testing. Interviewers expect logical reasoning, attention to detail, and a structured testing approach rather than extensive industry experience.

1. A Login Page Accepts Valid Credentials But Takes A Long Time To Open The Dashboard. How Would This Be Tested?

Ans:

The first step is to verify whether the login functionality works correctly with valid credentials. Next, measure the response time from clicking the Login button until the dashboard loads completely. Compare the actual loading time with the expected performance requirements. Check whether the delay occurs consistently across different browsers and network conditions. Record screenshots, logs, and timing details as evidence. If the delay exceeds acceptable limits, report it as a performance defect with all supporting information.

2. During Testing, The Submit Button Is Disabled Even After Filling All Mandatory Fields. What Should Be Done?

Ans:

Begin by verifying that every mandatory field contains valid input according to the requirements. Check for hidden validation rules such as minimum character length or required formats. Refresh the application and repeat the steps to confirm whether the issue is reproducible. Test the same scenario using different browsers and devices. Review the browser console for JavaScript errors if available. If the problem persists, log a defect with clear reproduction steps, expected behavior, actual behavior, and screenshots.

3. A Search Feature Returns Incorrect Results For Certain Keywords. How Would This Scenario Be Handled?

Ans:

• Test the search functionality using different types of keywords, including valid, invalid, partial, and special characters. Compare the returned results with the expected data in the application or database. 
• Verify whether filters or sorting options affect the search results. Repeat the test with different user roles if applicable. Record the exact keywords that produce incorrect results. 
• If incorrect results are consistently returned, report the defect along with the affected keywords and supporting evidence.

4. A User Reports That The Application Crashes After Uploading A Large File. What Testing Steps Would Be Followed?

Ans:

Reproduce the issue using the same file size and file format mentioned by the user. Verify the maximum supported upload size according to the requirements. Test uploads with smaller, medium, and larger files to identify the failure threshold. Observe whether any error messages are displayed before the crash. Check if the application recovers after restarting. Document the findings and report the issue if the application fails unexpectedly instead of handling the upload gracefully.

5. An Application Works Correctly In Chrome But Not In Microsoft Edge. How Would This Issue Be Investigated?

Ans:

Execute the same test cases in both browsers and compare the behavior. Check whether browser-specific settings or cached data influence the issue. Verify the browser versions being used during testing. Inspect UI alignment, functionality, and JavaScript execution differences. Capture screenshots and console logs if errors appear only in Microsoft Edge. Report the issue as a browser compatibility defect with complete environment details.

6. A Customer Says That A Password Reset Email Is Not Received. How Would This Be Tested?

Ans:

Verify that the email address entered is registered in the system. Check whether the password reset request is successfully submitted. Look in the inbox, spam, and junk folders for the email. Confirm that the email template and mail server are functioning correctly. Test the feature with multiple valid email accounts. If the email is never received despite successful requests, report the issue with detailed observations.

7. A Shopping Cart Shows The Wrong Total Price After Applying A Discount Coupon. How Would This Be Validated?.

Ans:

• Calculate the expected discount manually according to the business rules. Apply different valid and invalid coupons to verify their behavior.
•  Check whether taxes, shipping charges, and discounts are calculated correctly together. Test multiple quantities and different product combinations. 
• Compare the displayed total with the expected calculation. Report any mismatch as a functional defect with calculation details.

8. After Updating A User Profile, The Changes Are Not Saved. What Should Be Done?

Ans:

Verify that all required fields are completed correctly before saving. Refresh the page to determine whether the changes were actually stored. Log out and log back in to confirm whether the updated information appears. Test the feature with different user accounts and browsers. Check whether validation messages or server errors occur during saving. Report the issue if the application fails to persist the updated information.

9. A User Can Access An Admin Page Without Logging In. How Would This Be Tested?

Ans:

Attempt to access the admin page directly through its URL without authentication. Verify whether the application redirects unauthenticated users to the login page. Test different user roles to confirm proper authorization rules. Repeat the test in multiple browsers and private browsing mode. Capture evidence showing unauthorized access if it occurs. Report the issue immediately because it represents a critical security defect

10. The Application Displays Different Data After Refreshing The Same Page. How Would This Scenario Be Investigated?

Ans:

Refresh the page multiple times under identical conditions as part of software testing and compare the displayed data. Verify whether the data updates dynamically as expected. Check the backend database or API responses if available. Test using different browsers and user accounts. Determine whether caching issues contribute to inconsistent results. Document all observations and report the defect if the displayed data changes unexpectedly.

11. A Customer Reports That The Logout Button Does Not End The Session. How Would This Be Verified?

Ans:

• Log in with a valid account and click the Logout button. Attempt to access protected pages using the browser’s Back button or saved URLs. 
• Verify whether the session is properly terminated after logout. Clear browser cache and cookies to confirm consistent behavior. 
• Repeat the test in different browsers and devices. Report the issue if unauthorized access remains possible after logging out.

12. The Application Allows Duplicate User Registration. How Would This Scenario Be Tested?

Ans:

Register a new account using a valid email address. Attempt to create another account with the same email and identical information. Verify whether the application displays an appropriate validation message. Test duplicate usernames, phone numbers, or other unique fields if applicable. Check the database for duplicate records. Report the issue if duplicate accounts are created successfully.

13. A Mandatory Field Accepts Blank Spaces As Input. What Testing Approach Would Be Used?

Ans:

Enter only blank spaces into the mandatory field and submit the form. Verify whether the application trims unnecessary spaces before validation. Test combinations of spaces and valid characters. Repeat the scenario for all mandatory fields in the application. Compare the observed behavior with the functional requirements. Report the issue if blank spaces are accepted as valid input.

14. A Product Is Successfully Deleted But Still Appears In The Product List. How Would This Issue Be Investigated?

Ans:

Delete the selected product and verify whether a success message is displayed. Refresh the product list to check whether the deleted item still exists. Search for the product using different filters and sorting options. Verify the database record if access is available. Repeat the deletion using another product to confirm consistency. Report the defect if deleted products continue to appear in the application.

15. The Application Freezes While Switching Between Tabs. How Would This Problem Be Tested?

Ans:

Open multiple tabs within the application and switch between them repeatedly. Observe whether the application remains responsive during navigation. Monitor memory usage if testing tools are available. Repeat the scenario with different browsers and operating systems. Identify whether the issue occurs after a specific number of tab switches. Report the problem with detailed reproduction steps and observations.

16. An Error Message Is Displayed But Does Not Explain The Problem Clearly. How Should This Be Evaluated?

Ans:

• Trigger the error consistently and review the displayed message. Verify whether the message clearly explains the issue and suggests corrective action. 
• Compare it with the application’s usability guidelines. Test similar validation scenarios for consistency. 
• Capture screenshots of the unclear message. Report the issue as a usability defect with recommendations for improving user guidance.

17. The Application Accepts An Invalid Date Format. How Would This Scenario Be Tested?

Ans:

Enter different invalid date formats such as letters, symbols, or impossible calendar dates. Verify whether the application rejects invalid inputs with proper validation messages. Test boundary dates like leap years and month-end values. Compare the accepted format with the documented requirements. Repeat the tests across browsers. Report the issue if invalid dates are accepted..

18. A Downloaded Report Contains Missing Information. How Would This Be Validated?

Ans:

Generate the report using known test data and compare it with the application records. Verify whether all required fields are included in the downloaded file. Test different report formats if multiple export options exist. Check whether filters affect the missing information. Repeat the test with different user roles. Report the defect if the exported report consistently omits expected data.

19. The Same Transaction Is Processed Twice After Double-Clicking The Submit Button. How Would This Be Tested?

Ans:

Perform the transaction by clicking the Submit button only once and verify normal behavior. Repeat the transaction while double-clicking rapidly. Check whether duplicate records or payments are created. Verify whether the application disables the button after the first click. Test under slow network conditions as well. Report the issue if duplicate transactions are processed.

20. A User Receives An “Access Denied” Message Despite Having Valid Permissions. How Would This Scenario Be Investigated?

Ans:

• Verify that the user’s assigned role includes the required permissions. Test the same functionality with another user having identical access rights. 
• Check whether recent permission changes require a new login. Confirm that the application correctly recognizes the user’s role. 
• Review logs if available to identify authorization failures. Report the issue if valid users continue to receive incorrect access denial messages.

21. A User Can Submit A Form Multiple Times By Clicking The Submit Button Quickly. How Would This Be Tested?

Ans:

Execute the form submission normally and verify that a single record is created. Repeat the test by clicking the Submit button rapidly several times. Observe whether duplicate records are generated in the application or database. Test the behavior under slow network conditions to identify timing issues. Verify whether the button becomes disabled after the first click. Capture screenshots and logs if duplicates are created. Report the issue as a functional defect with complete reproduction steps.

22. A Newly Added Feature Causes Existing Features To Fail. What Testing Should Be Performed?

Ans:

Identify the features affected after the new functionality is introduced. Execute regression test cases covering related and dependent modules. Compare the current results with previous stable versions. Verify whether the failure occurs consistently across different environments. Document all impacted functionalities and their severity. Report the regression defects with detailed evidence. Recommend fixing the issues before releasing the application.

23. A User Enters Special Characters In A Name Field. How Would This Scenario Be Validated?

Ans:

Enter different special characters such as @, #, %, &, and *. Verify whether the application accepts or rejects them according to the requirements. Check that appropriate validation messages appear for invalid entries. Test combinations of alphabets, numbers, and special characters. Ensure the application remains stable without crashing. Record the observed behavior and compare it with the expected rules. Report any incorrect validation as a defect.

24. A Customer Complains That The Mobile Application Looks Broken On A Tablet. How Would This Be Tested?

Ans:

• Install the application on different tablet devices and screen sizes. Verify the alignment of buttons, text, images, and navigation menus. 
• Compare the layout with the design specifications. Test both portrait and landscape orientations. Ensure that all features remain functional despite screen size changes. 
• Capture screenshots of layout issues for documentation. Report any responsive design defects found during testing.

25. The Application Allows A User To Change Another User’s Information. How Would This Be Investigated?

Ans:

Log in with one user’s account and attempt to access another user’s profile. Try editing information using URLs or application navigation. Verify that proper authorization controls prevent unauthorized modifications. Repeat the test with different user roles. Confirm whether changes are reflected in the database. Capture evidence if unauthorized updates are successful. Report the issue immediately as a critical security defect.

26. A File Upload Works Correctly For PDF Files But Fails For DOCX Files. What Testing Steps Would Be Followed?

Ans:

Verify whether DOCX files are officially supported by the application. Upload different DOCX files with varying sizes and content. Compare the results with successful PDF uploads. Observe any error messages displayed during upload. Test uploads on different browsers and operating systems. Record logs and screenshots for failed attempts. Report the issue if supported DOCX files consistently fail.

27. A User Receives Different Results For The Same Search Query On Different Browsers. How Would This Be Handled?

Ans:

Perform identical search operations on multiple supported browsers. Verify that the application version and browser versions are current. Compare the returned search results carefully. Check whether browser caching affects the outcome. Repeat the tests using different user accounts and devices. Document any inconsistencies observed during execution. Report the browser compatibility issue with supporting evidence.

28. An Order Is Successfully Placed But Confirmation Is Not Displayed. How Would This Scenario Be Tested?

Place an order using valid test data and observe the application’s response. Verify whether the order is stored in the database. Check if confirmation emails or notifications are received. Refresh the application to confirm the order status. Repeat the test with different payment methods if applicable. Capture screenshots showing the missing confirmation message. Report the issue as a user experience defect.

29. The Application Accepts Negative Numbers In A Quantity Field. How Would This Be Validated?

Ans:

• Enter negative numbers into the quantity field and attempt to save the data. Verify whether validation prevents invalid quantities. Test zero, positive numbers, decimals, and extremely large values. 
• Compare the application’s behavior with business requirements. Ensure appropriate validation messages are displayed. 
• Repeat the scenario in different browsers. Report the defect if invalid quantities are accepted.

30. A Session Expires While A User Is Filling Out A Form. How Would This Situation Be Tested?

Ans:

Log in and begin completing a lengthy form. Wait until the configured session timeout occurs. Attempt to submit the completed form afterward. Verify whether the user receives an informative session expiration message. Check whether unsaved data can be recovered after logging in again. Repeat the test with different timeout durations if possible. Report any unexpected loss of data or incorrect behavior.

31. A Payment Is Deducted But The Order Is Not Created. How Would This Issue Be Investigated?

Ans:

Perform a payment transaction using valid payment details. Verify whether the payment is successfully processed by the payment gateway. Check whether the order appears in the application database. Compare payment records with order records for consistency. Capture transaction IDs and timestamps for investigation. Repeat the test using different payment methods. Report the issue as a high-priority functional defect.

32. The Application Displays Incorrect Currency Symbols For International Users. How Would This Be Tested?

Ans:

Change the application’s region or language settings to different countries. Verify that the correct currency symbols are displayed throughout the application. Check product pages, invoices, and payment screens. Compare the displayed currency with business requirements. Test multiple browsers and devices for consistency. Record any incorrect currency formatting. Report localization defects with screenshots.

33. A Notification Appears Multiple Times For The Same Event. How Would This Be Validated?

Ans:

Trigger the event responsible for generating the notification. Observe whether a single notification appears as expected. Repeat the event several times to verify consistency. Check whether duplicate notifications are stored in the notification history. Test across different user accounts if applicable. Record screenshots and timestamps for duplicate notifications. Report the issue with detailed reproduction steps.

34. A Password Field Displays Plain Text Instead Of Hidden Characters. How Would This Scenario Be Tested?

Ans:

• Navigate to the login or registration page and enter a password. Verify that each character is masked during typing. Test the field after enabling browser autofill and password managers.
•  Repeat the scenario on different browsers and mobile devices. Ensure passwords remain hidden throughout the process. 
• Capture screenshots demonstrating the issue. Report it immediately as a security and usability defect.

35. A User Can Access Restricted Pages By Using The Browser Back Button After Logout. What Testing Should Be Done?

Ans:

Log in and navigate to a protected page. Log out using the application’s Logout option. Press the browser Back button several times. Verify whether protected pages remain accessible without authentication. Refresh the page to confirm the session status. Repeat the scenario across multiple browsers. Report the issue if sensitive pages remain accessible.

36. A Database Update Is Successful But The User Interface Still Shows Old Information. How Would This Be Investigated?

Ans:

Update the data through the application and verify the database changes. Refresh the application to determine whether the updated information appears. Clear browser cache if necessary and repeat the test. Check whether caching mechanisms delay data updates. Test the same scenario using different user accounts. Document all observations carefully. Report the issue if stale data continues to be displayed.

37. The Login Page Accepts SQL Commands As Username Input. How Would This Scenario Be Tested?

Ans:

Enter common SQL injection test strings into the username and password fields. Verify whether the application treats the input as plain text. Ensure error messages do not reveal database information. Test different SQL injection patterns while following security testing guidelines. Observe the application’s response carefully. Record all findings with screenshots if vulnerabilities exist. Report the issue immediately as a critical security defect.

38. The Application Crashes When The Internet Connection Is Interrupted During Data Saving. How Would This Be Validated?

Ans:

Begin saving valid data and disconnect the internet during the operation. Observe whether the application handles the interruption gracefully. Verify whether appropriate error messages are displayed. Reconnect the network and confirm whether the data is saved correctly or rolled back. Repeat the test under different network conditions. Capture logs and screenshots of the failure. Report any unexpected crashes or data corruption.

39. A User Reports That Notifications Are Received Hours Late. How Would This Be Tested?

Ans:

• Trigger notifications under normal operating conditions. Record the exact time when the event occurs. Compare it with the actual notification delivery time. 
• Test the behavior on multiple devices and network connections. Verify server and device time synchronization. C
• heck whether delays occur consistently or randomly. Report the issue if notification delivery exceeds acceptable limits.

40. A Mandatory Checkbox Can Be Left Unchecked While Completing Registration. How Would This Scenario Be Tested?

Ans:

Attempt to submit the registration form without selecting the mandatory checkbox during software testing. Verify whether the application prevents form submission. Check that a clear validation message explains the missing requirement. Repeat the scenario using different browsers and devices. Test after refreshing the page to ensure consistent behavior. Compare the results with the functional requirements. Report the defect if registration succeeds without the required confirmation.

41. A User Successfully Changes The Password But Cannot Log In With The New Password. How Would This Be Tested?

Ans:

Change the password using valid credentials and verify that a success message is displayed. Log out of the application and attempt to log in using the new password. Also verify that the old password is no longer accepted. Repeat the test with different password combinations that meet the password policy. Check whether the password update is reflected in the database if access is available. Record screenshots and logs during testing. Report the issue if the new password fails despite successful confirmation.

42. A Web Page Loads Correctly But Some Images Are Missing. How Would This Scenario Be Investigated?

Ans:

• Open the web page in different supported browsers and devices to verify whether the missing images appear consistently. Refresh the page and clear the browser cache before testing again. 
• Inspect whether broken image links or server errors exist. Verify that image files are available on the server. 
• Compare the page with the design specifications. Capture screenshots showing the missing images. Report the defect with complete environment details.

43. An Application Displays Incorrect Date And Time For Users In Different Countries. How Would This Be Validated?

Ans:

Change the system time zone and application region settings to different countries. Verify that dates and times are displayed according to local standards. Test user activities such as login history, reports, and notifications. Compare the displayed values with the expected local time. Repeat the test using multiple browsers and devices. Document any inconsistencies found during testing. Report localization issues if incorrect date or time formats are displayed.

44. A Customer Reports That Deleted Records Reappear After Refreshing The Page. How Would This Be Tested?

Ans:

Delete a record and confirm that a success message is displayed. Refresh the application and verify whether the deleted record returns. Check the database to determine whether the record was actually removed. Repeat the deletion using different records and user accounts. Verify whether synchronization or caching issues are involved. Capture screenshots before and after refreshing the page. Report the issue if deleted records reappear.

45. A User Is Able To Enter More Characters Than The Maximum Allowed Limit. How Would This Be Validated?

Ans:

Identify the maximum character limit specified in the requirements. Enter text exceeding the allowed limit into the input field. Verify whether the application prevents additional input or displays a validation message. Test using copy-paste as well as manual typing. Repeat the test in different browsers and devices. Record the actual number of accepted characters. Report the issue if the application allows inputs beyond the defined limit.

46. The Application Automatically Logs Out Users Before The Configured Timeout. How Would This Scenario Be Tested?

Ans:

Log in and remain inactive while monitoring the session duration. Compare the actual logout time with the configured session timeout. Repeat the test under different browsers and network conditions. Verify whether background activities incorrectly trigger session expiration. Check application logs if available. Document the observed timeout duration. Report the issue if users are logged out earlier than expected.

47. A User Receives A Success Message Even Though The Data Is Not Saved. How Would This Be Investigated?

Ans:

• Perform the save operation using valid data and observe the displayed success message. Refresh the page and verify whether the data is actually stored. 
• Check the database if testing access is available. Repeat the same operation with different data values. 
• Ensure that success messages accurately reflect the operation outcome. Capture screenshots and logs for documentation. Report the issue if the message is misleading.

48. The Application Allows The Same Coupon Code To Be Used Multiple Times When Only One Use Is Allowed. How Would This Be Tested?

Ans:

Apply the coupon code successfully during the first eligible transaction. Complete another transaction using the same coupon. Verify whether the application correctly blocks repeated usage. Test using different user accounts if the restriction applies per customer. Compare the behavior with business rules. Capture transaction details and screenshots. Report the defect if coupon usage restrictions are not enforced..

49. A User Cannot Upload A Profile Picture Even Though The File Meets All Requirements. How Would This Be Validated?

Ans:

Verify that the image format, size, and dimensions match the supported requirements. Upload different images with similar properties to identify patterns. Test the upload feature across multiple browsers and devices. Observe whether any validation or server error messages appear. Check whether the uploaded file is stored correctly. Record logs and screenshots of failed uploads. Report the issue if valid images consistently fail.

50. A User Receives An Unexpected Error While Printing A Report. How Would This Be Tested?

Ans:

Generate the report successfully before attempting to print it. Verify printer settings and browser print functionality. Test printing from different browsers and operating systems. Compare the behavior with other report types. Capture the complete error message and reproduction steps. Check whether the report downloads successfully before printing. Report the issue if printing fails unexpectedly.

51. The Application Accepts Future Dates In A Date Of Birth Field. How Would This Scenario Be Tested?

Ans:

Enter a future date into the Date of Birth field and attempt to submit the form. Verify whether the application rejects the invalid input. Test today’s date, past dates, and boundary values for comparison. Ensure appropriate validation messages are displayed. Repeat the scenario across multiple browsers. Compare the behavior with business requirements. Report the defect if future birth dates are accepted.

52. A User’s Shopping Cart Becomes Empty After Refreshing The Browser. How Would This Be Investigated?

Ans:

• Add multiple products to the shopping cart and verify that they appear correctly. Refresh the browser and check whether the cart contents remain. 
• Repeat the test after logging out and logging back in. Verify cart persistence across different browsers and devices. 
• Check whether session handling affects the cart data. Capture screenshots before and after refreshing. Report the issue if cart items disappear unexpectedly.

53. A Search Filter Produces Different Results Each Time It Is Applied. How Would This Be Tested?

Ans:

Apply the same search filter repeatedly without changing any data. Compare the returned results after each execution. Verify whether the underlying data changes during testing. Test different filter combinations and sorting options. Repeat the scenario using multiple browsers. Record any inconsistent results with screenshots. Report the defect if identical filters produce inconsistent outcomes.

54. A User Can Continue Using The Application Even After The Account Has Been Disabled. How Would This Be Validated?

Ans:

Disable the user’s account through the administration panel during software testing. Attempt to continue using the application without logging out. Verify whether access is immediately restricted. Test logging in again using the disabled account. Repeat the scenario with different user roles. Capture evidence showing unauthorized access. Report the issue as a high-priority security defect if access is still permitted.

55. The Application Displays Raw System Error Messages Instead Of User-Friendly Messages. How Would This Scenario Be Tested?

Ans:

Perform actions that intentionally trigger application errors under controlled conditions. Observe whether technical error details are displayed to the user. Verify that user-friendly messages appear without exposing internal system information. Repeat the test for different modules. Capture screenshots of technical error messages. Compare them with usability and security guidelines. Report the issue if sensitive details are exposed.

56. A Downloaded Excel Report Contains Incorrect Column Headers. How Would This Be Tested?

Ans:

Generate the Excel report using valid test data. Compare each column header with the functional requirements. Verify that the order and names of the columns are correct. Test reports generated under different filters and user roles. Ensure that the data aligns with the correct headers. Capture screenshots of incorrect columns. Report the issue if mismatched headers are found.

57. The Application Does Not Display Validation Messages For Required Fields. How Would This Be Investigated?

Ans:

• Leave required fields empty and attempt to submit the form. Verify whether the application blocks submission appropriately. 
• Check whether validation messages appear beside the affected fields. Repeat the scenario using different browsers and screen resolutions. 
• Compare the behavior with UI specifications. Record screenshots of missing validation messages. Report the defect if users receive no guidance.

58. Multiple Users Edit The Same Record At The Same Time And One User’s Changes Are Lost. How Would This Be Tested?

Ans:

Log in using two separate user accounts. Open the same record in both sessions. Save changes from one account and then save different changes from the second account. Observe how the application handles concurrent updates. Verify whether conflict messages or version control mechanisms are implemented. Record all observations carefully. Report the issue if data is overwritten without warning.

59. A User Can Access Sensitive Information By Changing The URL. How Would This Scenario Be Validated?

Ans:

Log in with a standard user account and manually modify the URL to access restricted resources. Verify whether authorization checks prevent unauthorized access. Test multiple restricted pages using different user roles. Ensure that the application redirects unauthorized users appropriately. Capture screenshots showing any successful unauthorized access. Document all reproduction steps. Report the issue immediately as a critical security vulnerability.

60. The Application Becomes Slow When Hundreds Of Users Access It Simultaneously. How Would This Be Evaluated?

Ans:

• Perform load testing using an appropriate performance testing tool to simulate multiple concurrent users. Monitor response times, CPU usage, memory utilization, and server performance. 
• Identify the point at which performance begins to degrade. Verify that critical business functions continue to operate correctly under load. 
• Record performance metrics throughout the test execution. Compare the results with performance requirements. Report bottlenecks and recommend optimization where necessary.

61. A User Receives A “Page Not Found” Error After Clicking A Valid Menu Link. How Would This Be Tested?

Ans:

• Click the menu link and verify whether the correct page opens successfully. Repeat the test using different browsers and devices to confirm consistency. 
• Check whether the URL generated by the application is valid and accessible. Refresh the page and clear the browser cache before testing again. 
• Compare the navigation with the functional requirements. Capture screenshots and note the exact URL causing the error. Report the issue if the page consistently displays a “Page Not Found” error.

62. A User Can Submit A Registration Form Without Accepting The Terms And Conditions. How Would This Scenario Be Validated?

Ans:

Leave the Terms and Conditions checkbox unchecked and complete all other mandatory fields. Attempt to submit the registration form and observe the result. Verify whether the application blocks the submission and displays an appropriate validation message. Repeat the test on multiple browsers and mobile devices. Compare the behavior with the business requirements. Record screenshots and test results for documentation. Report the issue if registration succeeds without user consent.

63. A Product Price Changes During Checkout Without Any User Action. How Would This Be Investigated?

Ans:

Add a product to the shopping cart and note its displayed price. Proceed through the checkout process without modifying the order. Verify whether the price remains consistent throughout the transaction. Test with different products, discounts, and browsers. Compare the displayed price with the product database if available. Capture screenshots showing the price difference. Report the defect if unexpected price changes occur.

64. The Application Displays Duplicate Records After Refreshing A List Page. How Would This Be Tested?

Ans:

Open the list page and verify the number of displayed records. Refresh the page several times without changing any data. Observe whether duplicate entries appear after each refresh. Compare the displayed data with the database records. Repeat the scenario using different user accounts. Capture screenshots showing duplicate records. Report the issue if duplicate entries are consistently displayed.

65. A User Cannot Access The Dashboard Immediately After Successful Login. How Would This Scenario Be Tested?

Ans:

• Log in using valid credentials and verify that authentication succeeds. Observe whether the application redirects to the dashboard correctly. 
• Refresh the page and repeat the login process several times. Test the same scenario in multiple browsers and network conditions. 
• Verify whether session creation is successful. Capture logs and screenshots if redirection fails. Report the issue if users cannot access the dashboard after login.

66. A Mandatory Drop-Down List Allows The Default Value To Be Submitted. How Would This Be Validated?

Ans:

Leave the drop-down field unchanged at its default value and complete the remaining required fields. Attempt to submit the form and observe the behavior. Verify whether the application forces the user to select a valid option. Repeat the test for all mandatory drop-down fields. Compare the behavior with the specified requirements. Record screenshots of the submitted form. Report the defect if default values are accepted..

67. The Application Displays Incorrect Information After Switching User Accounts. How Would This Be Investigated?

Ans:

Log in with the first user account and view the profile information. Log out and immediately log in with another user account. Verify that only the second user’s information is displayed. Repeat the scenario using different browsers and devices. Check whether cached data affects the displayed information. Capture screenshots of incorrect user data. Report the issue if account information is mixed

68. A Customer Reports That The Application Freezes While Generating Reports. How Would This Be Tested?

Ans:

Generate reports with small, medium, and large amounts of data. Observe whether the application remains responsive during report creation. Monitor system performance and memory usage if tools are available. Repeat the test under different browsers and operating systems. Record the time required to generate each report. Capture screenshots if the application freezes. Report the issue if report generation consistently causes application hangs.

69. The Application Accepts Invalid Email Addresses During Registration. How Would This Scenario Be Validated?

Ans:

• Enter various invalid email formats, such as missing ‘@’ symbols or invalid domains. Attempt to submit the registration form with each input. 
• Verify that proper validation messages appear for incorrect formats. Test valid email addresses for comparison. Repeat the scenario across multiple browsers. 
• Record the accepted invalid email formats. Report the issue if invalid email addresses are successfully registered.

70. A User Is Logged Out Automatically While Uploading A Large File. How Would This Be Tested?

Ans:

Log in and begin uploading a large supported file. Observe whether the session remains active throughout the upload process. Verify whether session timeout settings interrupt the upload. Repeat the test with files of different sizes. Test under various network conditions. Capture logs and screenshots during logout. Report the issue if uploads fail because of unexpected session expiration.

71. A Notification Email Contains Incorrect User Information. How Would This Be Investigated?

Ans:

Trigger the notification using valid test data. Compare the email contents with the user’s profile information. Verify that names, email addresses, and transaction details are accurate. Test notifications for multiple user accounts. Check whether email templates are populated correctly. Capture screenshots of incorrect email content. Report the defect if incorrect user information is included.

72. A Search Function Does Not Return Newly Added Records. How Would This Be Tested?

Ans:

Create a new record successfully and verify that it appears in the database. Search for the newly added record using different keywords. Refresh the application and repeat the search. Test with different search filters and sorting options. Compare the search results with expected data. Record screenshots of missing records. Report the issue if newly added records cannot be found.

73. A User Can Access The Same Application Using Multiple Simultaneous Sessions. How Would This Scenario Be Validated?

Ans:

Log in with the same account on two different browsers or devices. Perform activities in both sessions simultaneously. Verify whether the application allows multiple active sessions according to the requirements. Check whether session invalidation occurs after a new login. Repeat the scenario using different devices. Record observations and screenshots. Report the issue if session handling does not match the expected behavior.

74. A Data Export Contains Special Characters Instead Of Expected Text. How Would This Be Tested?

Ans:

• Export data containing different languages and special characters. Open the exported file using supported applications. 
• Verify that all characters are displayed correctly without corruption. Compare the exported content with the application data. 
• Repeat the test using different export formats if available. Capture screenshots of incorrect character encoding. Report the issue if exported data is unreadable.

75. The Application Allows Submission Of An Empty Shopping Cart. How Would This Be Validated?

Ans:

Open the shopping cart without adding any products. Attempt to proceed to checkout and complete the purchase. Verify whether the application blocks the transaction. Check for clear validation messages explaining the issue. Repeat the scenario on different browsers and devices. Capture screenshots of the checkout process. Report the defect if empty orders are successfully placed.

76. The Browser Refresh Button Causes Duplicate Form Submission. How Would This Be Investigated?

Ans:

Complete a form submission successfully using valid data. Refresh the browser immediately after submission. Verify whether the application resubmits the request automatically. Check the database for duplicate records. Repeat the test under slow network conditions. Record screenshots and timestamps for duplicate entries. Report the issue if duplicate submissions occur.

77. The Application Crashes When Copying And Pasting Large Amounts Of Text. How Would This Be Tested?

Ans:

Prepare a large block of valid text and paste it into supported input fields. Observe whether the application remains stable during the operation. Test different text sizes and character combinations. Verify that character limits are enforced correctly. Repeat the scenario in multiple browsers. Capture screenshots if the application crashes. Report the defect with all reproduction steps.

78. A User Cannot Save Changes After Editing A Record For A Long Time. How Would This Be Validated?

Ans:

Open a record and begin editing it without saving immediately. Wait for an extended period before attempting to save the changes. Verify whether the session remains active during editing. Check for timeout messages or unsaved changes. Repeat the test with different timeout configurations if possible. Record screenshots and logs. Report the issue if valid changes cannot be saved.

79. A Report Displays Different Totals Than The Dashboard. How Would This Be Investigated?

Ans:

• Open the dashboard and note the displayed totals. Generate the corresponding report using the same filters and date range. Compare all totals carefully for consistency. 
• Verify the database values if access is available. Repeat the test using different user roles and report types. 
• Capture screenshots highlighting the differences. Report the issue if inconsistent totals are found.

80. A User Can Delete Important Records Without Any Confirmation Message. How Would This Be Tested?

Ans:

Attempt to delete an important record from the application. Observe whether a confirmation dialog appears before deletion. Verify that users have an opportunity to cancel the action. Repeat the test for different modules containing critical data. Compare the behavior with usability requirements. Capture screenshots of the deletion process. Report the defect if records are deleted without confirmation.

81. A User Receives A Success Message After Payment, But The Payment History Is Empty. How Would This Be Tested?

Ans:

Complete a payment using valid payment details and verify that the success message appears. Navigate to the payment history page and check whether the transaction is listed. Refresh the page and log in again to confirm the result. Compare the payment information with the database or payment gateway records if available. Repeat the test using different payment methods. Capture screenshots and transaction IDs for reference. Report the defect if successful payments do not appear in the payment history.

82. The Application Displays An Incorrect Error Message For Invalid Login Credentials. How Would This Scenario Be Validated?

Ans:

• Attempt to log in using invalid usernames and passwords. Verify that the displayed error message accurately explains the authentication failure. 
• Ensure that sensitive information is not exposed in the message. Repeat the test with locked, inactive, and expired accounts. 
• Compare the behavior with the application requirements. Record screenshots of incorrect messages. Report the issue if misleading or incorrect error messages are displayed.

83. A User Can Submit The Same Feedback Form More Than Once Accidentally. How Would This Be Tested?

Ans:

Submit the feedback form successfully using valid data. Immediately attempt to submit the same feedback again without making changes. Verify whether duplicate feedback entries are created. Test the scenario by refreshing the browser after submission. Check the database for duplicate records if possible. Capture screenshots and timestamps during testing. Report the issue if duplicate feedback submissions are accepted.

84. An Uploaded Document Is Saved Successfully But Cannot Be Downloaded Later. How Would This Be Investigated?

Ans:

Upload a valid document and confirm that the upload completes successfully. Navigate to the document management section and attempt to download the file. Verify whether the downloaded file opens correctly. Test with different document formats and file sizes. Compare the stored file with the original version. Record any download errors and screenshots. Report the issue if uploaded files cannot be downloaded.

85. A User’s Profile Picture Appears Correctly On One Page But Not On Another. How Would This Be Validated?

Ans:

• Upload a profile picture using a supported image format. Navigate through different sections of the application where the profile picture should appear. 
• Verify that the same image is displayed consistently. Refresh the pages and repeat the test in multiple browsers. 
• Check whether caching affects the displayed image. Capture screenshots showing inconsistencies. Report the issue if the profile picture is missing on specific pages.

86. The Application Allows A User To Submit A Form Without An Internet Connection. How Would This Be Tested?

Ans:

Disconnect the internet connection before submitting the completed form. Observe whether the application displays an appropriate network error message. Verify that incomplete submissions are not stored incorrectly. Reconnect the network and confirm whether the form can be submitted successfully. Repeat the scenario under different network interruptions. Capture logs and screenshots. Report the issue if invalid submissions are accepted offline.

87. A User Is Redirected To The Wrong Page After Completing Registration. How Would This Be Investigated?

Ans:

Complete the registration process using valid information. Observe the page displayed immediately after successful registration. Compare the redirection with the expected user flow. Repeat the test using different browsers and devices. Verify whether user roles influence the redirection. Record screenshots of the incorrect page. Report the issue if users are redirected incorrectly.

88. The Application Displays Different Font Sizes On Different Browsers. How Would This Be Validated?

Ans:

Open the application in all supported browsers using the same screen resolution. Compare the font sizes and text alignment on each browser. Verify that the displayed content matches the design specifications. Test different zoom levels and display settings. Capture screenshots highlighting visual differences. Document the browser versions used during testing. Report any UI inconsistencies found.

89. A User Can Access Old Cached Information After Updating Records. How Would This Scenario Be Tested?

Ans:

• Update a record successfully and verify that the changes are saved. Refresh the application and navigate back to the updated record. 
• Clear the browser cache and compare the displayed information. Repeat the scenario in multiple browsers. Verify whether server-side caching delays updates. 
• Capture screenshots showing outdated information. Report the issue if cached data continues to appear.

90. The Application Stops Responding After Multiple Failed Login Attempts. How Would This Be Investigated?

Ans:

Attempt several invalid login attempts using incorrect credentials. Observe whether the application responds normally after each attempt. Verify whether account lockout policies are applied correctly. Test the application with different user accounts and browsers. Monitor response time throughout the test. Record screenshots and logs if the application becomes unresponsive. Report the issue if repeated failures cause application instability.

91. A User Can Delete Another User’s Comments Without Permission. How Would This Be Tested?

Ans:

Log in as a regular user and locate comments created by another account during software testing. Attempt to delete those comments using available application options or direct URLs. Verify that authorization controls prevent unauthorized deletion. Repeat the test using different user roles. Confirm whether the comments remain unchanged. Capture screenshots if unauthorized actions succeed. Report the issue immediately as a critical security defect.

92. A Report Shows Missing Records Only During Peak Usage Hours. How Would This Be Validated?

Ans:

Generate reports during periods of normal and high application usage. Compare the report contents from both executions. Verify whether the missing records exist in the database. Monitor application performance while generating reports. Repeat the test with different report filters. Capture evidence showing missing records. Report the issue if high system load affects report accuracy..

93. The Search Function Ignores Uppercase And Lowercase Differences Incorrectly. How Would This Be Tested?

Ans:

Search for the same keyword using uppercase, lowercase, and mixed-case letters. Verify whether the search behavior matches the expected requirements. Compare the search results for consistency. Test different words containing special characters as well. Repeat the scenario across supported browsers. Record screenshots of inconsistent search results. Report the issue if case sensitivity behaves incorrectly.

94. A User Is Able To Complete Checkout Even Though Inventory Is Out Of Stock. How Would This Be Investigated?

Ans:

• Reduce the inventory quantity to zero for a selected product. Add the product to the shopping cart and attempt checkout. 
• Verify whether the application prevents the purchase. Compare the displayed inventory with the actual stock level. Repeat the test using multiple products. 
• Capture screenshots of successful checkout attempts. Report the defect if out-of-stock products can be purchased.

95. The Application Displays Incorrect Pagination After Applying Filters. How Would This Be Tested?

Ans:

Apply search filters that return multiple pages of results. Navigate through each page and verify that the pagination is accurate. Remove and reapply filters to observe consistency. Compare the displayed record count with the database if available. Test different combinations of filters. Capture screenshots showing pagination errors. Report the issue if page navigation becomes incorrect.

96. A User Cannot Log In Immediately After Account Activation. How Would This Be Validated?

Ans:

Activate a newly created user account through the required process. Attempt to log in immediately using valid credentials. Verify whether account activation is completed successfully. Repeat the test after waiting for a short period to identify synchronization delays. Test across multiple browsers. Capture screenshots and logs of failed login attempts. Report the issue if activated users cannot access the application.

97. The Application Allows Invalid Characters In A Phone Number Field. How Would This Be Tested?

Ans:

Enter alphabets, symbols, spaces, and mixed characters into the phone number field. Verify whether only valid numeric input is accepted according to requirements. Test minimum and maximum length restrictions. Compare the application’s validation with the business rules. Repeat the test across multiple browsers. Record accepted invalid inputs. Report the issue if incorrect characters are allowed.

98. A User Receives Duplicate SMS Notifications For A Single Transaction. How Would This Be Investigated?

Ans:

Complete a transaction that triggers an SMS notification. Verify whether only one message is received. Repeat the transaction under different network conditions. Compare SMS delivery timestamps and message contents. Test multiple user accounts if applicable. Capture evidence of duplicate notifications. Report the issue if multiple SMS messages are generated for a single event.

99. The Dashboard Loads Correctly But Some Charts Display Incorrect Data. How Would This Be Validated?

Ans:

Open the dashboard and verify that all charts load successfully. Compare the chart values with the underlying database or report data. Test different filters and date ranges to verify consistency. Refresh the dashboard several times and observe the results. Repeat the scenario using different user roles. Capture screenshots highlighting incorrect chart values. Report the issue if chart data does not match the source data.

100. A Critical Production Issue Is Reported By A Customer Immediately After Deployment. How Would This Situation Be Handled?

Ans:

• First, reproduce the reported issue in the production-like environment using the provided details. Assess the impact, severity, and number of users affected by the problem. Collect logs, screenshots, timestamps, and reproduction steps to support the investigation. 
• Inform the development team and relevant stakeholders immediately with complete defect information. Verify the fix once it is deployed and perform regression testing on related functionalities. 
• Confirm that the issue is fully resolved without introducing new defects. Finally, document the incident, root cause, resolution, and lessons learned to improve future release quality.