Questions in: Project Oriented Questions

Right Answer:

Here are common types of bugs found in most projects:

1. ✅ Functional Bugs
The feature doesn’t work as expected.
Example: Clicking “Submit” does nothing.

2. 🔐 Security Bugs
Sensitive data is exposed or access is not restricted.
Example: A user can access another user’s account details.

3. 🖥 UI/UX Bugs
Design, alignment, or layout issues.
Example: Button overlaps text on small screens.

4. ⏱ Performance Bugs
Slow loading or system hangs.
Example: Page takes 10+ seconds to load.

5. 📤 Integration Bugs
Modules don’t interact properly.
Example: Data from the form isn’t saved in the database.

6. 🔁 Compatibility Bugs
The app doesn’t work on certain devices/browsers.
Example: Works in Chrome but crashes in Safari.

7. 🧮 Calculation/Logic Bugs
Wrong results or business logic failure.
Example: Discount is calculated incorrectly.

🎯 In simple words:
We usually find bugs related to broken functions, design issues, wrong data, or performance.

Right Answer:

If a developer disagrees with the severity or priority I assigned, I will:

✅ Recheck the bug against the requirements and user impact
✅ Explain why I assigned that severity/priority, based on how it affects functionality or user experience
✅ Listen to the developer’s point of view calmly
✅ If we still don’t agree, I escalate the issue to the team lead, business analyst, or product owner for clarification and final decision

🎯 In simple words:
I discuss respectfully, justify my decision, and involve the team if needed — to make sure the right judgment is made.

Right Answer:

We develop software (test scripts or automation tools) to test software because it:

✅ Saves Time – Repeating manual tests is time-consuming. Automation runs faster.
✅ Improves Accuracy – Automation avoids human errors in repetitive tasks.
✅ Increases Test Coverage – We can run more test cases in less time.
✅ Supports Continuous Testing – Useful in Agile and DevOps environments.
✅ Makes Regression Testing Easier – Quickly checks that old features still work after changes.

🎯 In simple words:
We write software to test software so we can test faster, smarter, and more reliably.

Right Answer:

Defect Removal Efficiency (DRE) is a metric that shows how effectively your testing process is catching defects before the product is released.

📌 Formula:

DRE = (Defects found during testing) ÷ (Defects found during testing + Defects found after release) × 100

🧮 Example:
If 90 defects were found during testing, and 10 were found after release:
DRE = (90 / (90 + 10)) × 100 = 90%

🎯 In Simple Words:
DRE tells how many bugs you caught before release. Higher DRE = better testing quality.

Right Answer:

Some common security problems I faced during testing include:

✅ 1. Unauthorized access (users accessing restricted data)
🔒 Solution: Verified proper role-based access controls and implemented session timeouts.

✅ 2. SQL Injection
🔒 Solution: Ensured all input fields used parameterized queries and validated user input.

✅ 3. Sensitive data exposure (e.g., passwords in plain text)
🔒 Solution: Checked for data encryption and secure storage (like hashing passwords).

✅ 4. Broken authentication
🔒 Solution: Tested login/logout flows, multi-session behavior, and password reset mechanisms.

🎯 In Simple Words:
I tested for security flaws like data leaks, injection attacks, and weak access. I worked with developers to fix these using secure coding, validations, and access restrictions.

Right Answer:

It depends on the complexity of the application and type of testing:

• On average, I write 5 to 10 test scripts per day for medium-complex features.

• For simple modules (like form validation), I can write 10+ scripts/day.

• For complex modules (like workflows or payment flows), it may be 2–3 scripts/day with deeper logic and validations.

🎯 In my recent project:
I wrote around 120–150 test scripts in total, averaging 6–8 scripts per day during active scripting phase.

Right Answer:

If the developer takes more time:

✅ I do risk-based testing to cover critical areas first
✅ Start testing completed modules in parallel
✅ Use test automation or add testers if needed
✅ Use buffer time or re-negotiate deadlines
✅ Escalate to PM if slippage continues

🎯 Goal: Adjust smartly without compromising quality or delivery.

Right Answer:

There is no fixed number of “acceptable defects” for all projects. It depends on:

✅ 1. Project Type
– Critical projects (like banking, healthcare, aviation) require zero critical defects.
– In non-critical projects (like internal tools or small apps), minor defects may be accepted if they don’t affect functionality.

✅ 2. Defect Severity
– High-severity or blocker defects: 0 acceptable
– Medium severity: Very few (must be clearly communicated)
– Low severity (UI/minor issues): May be accepted based on business decision

✅ 3. Client Agreement / SLA
– Some projects define defect leakage rate goals (e.g., less than 5% defects after release)

🎯 Example Standard:

✅ 4. Quality Goal
– The goal is always: “Zero critical defects” before go-live.
– Focus is on user satisfaction and business impact — not just defect count.

🔔 Tip for Interviews:
Say: “We aim for zero critical/high defects before release. Minor UI or low-priority bugs may be accepted if approved by the client.

Right Answer:

System testing is performed after integration testing and before user acceptance testing (UAT). It involves testing the entire application as a whole to ensure it meets the specified requirements.

Here’s how we do system testing in a project:

🔷 1. Understand Requirements
– Review Software Requirements Specification (SRS) to identify test conditions.

🔷 2. Prepare Test Plan
– Define scope, objectives, resources, schedule, and tools.

🔷 3. Write Test Cases
– Create test cases that cover all end-to-end scenarios, including positive and negative flows.

🔷 4. Set Up Test Environment
– Use a stable environment that simulates production with real-like data.

🔷 5. Execute Test Cases
– Perform manual or automated testing of the complete system features and workflows.

🔷 6. Log Defects
– Report any mismatches or failures using a bug tracking tool like Jira.

🔷 7. Regression Testing
– Re-test the fixed issues and ensure nothing else is broken.

🔷 8. Prepare Test Summary Report
– Share test results, defect stats, and coverage with stakeholders.

🎯 In simple words:
System testing means testing the full application as a user would, to ensure all parts work correctly together before delivery.

Right Answer:

Architecture means how your project is structured — in terms of layers, technologies, and how data flows. Here’s how you can answer:

✅ Example Answer (Web-Based Application):

My project follows a 3-tier architecture:

1. 🔷 Presentation Layer (Frontend):
– Built using HTML, CSS, JavaScript (or React/Angular)
– Handles user input and displays output

2. 🔷 Business Logic Layer (Backend):
– Built using technologies like Java/.NET/PHP
– Contains all the processing logic (login, transactions, etc.)

3. 🔷 Data Layer (Database):
– Uses SQL Server / MySQL / Oracle
– Stores and retrieves application data

🔁 Communication:
– API calls (REST) connect frontend and backend
– Backend interacts with the database to store and fetch data

✅ Bonus (If Used):
– We also used JWT for authentication and hosted the project on AWS/Azure
– CI/CD pipelines were used for automatic deployment

🎯 In Simple Words:
My project has frontend, backend, and database layers. Each has its own job, and they work together using APIs to serve the user.

Right Answer:
My role in the project would be to design, develop, and execute automated test scripts, ensure software quality through thorough testing, collaborate with developers to identify and resolve issues, and contribute to continuous improvement of testing processes.

Right Answer:
In our project, the connection to the database is established using a database connection string, which includes the database type, server address, database name, and authentication credentials. We use an Object-Relational Mapping (ORM) tool or a database driver to interact with the database. The typical procedure involves:

1. **Establishing a Connection**: Using the connection string to open a connection to the database.
2. **Executing Queries**: Sending SQL commands or using ORM methods to perform CRUD operations (Create, Read, Update, Delete).
3. **Handling Results**: Processing the results returned from the database.
4. **Closing the Connection**: Properly closing the connection to free up resources.

Right Answer:
I am currently working on a web application project that focuses on enhancing user experience through a responsive design. My role involves developing and implementing automated test scripts to ensure the application functions correctly across different devices and browsers. We are using tools like Selenium for automation and JIRA for tracking bugs and project progress. The project aims to improve performance and reliability while delivering new features based on user feedback.

Right Answer:
I chose software testing because I enjoy ensuring that products meet quality standards and function correctly, which ultimately leads to better user experiences.

Right Answer:
The language of engineering is often considered to be mathematics, as it provides the foundational principles and tools for modeling, analyzing, and solving engineering problems.

Right Answer:
My academic project focused on developing a web-based application for managing student records. I designed the user interface using HTML, CSS, and JavaScript, while the backend was built with Python and Flask. The application allowed users to add, update, and delete student information, and it included features like search and filtering. I also implemented unit tests to ensure the functionality was reliable and performed user acceptance testing to gather feedback for improvements.

Right Answer:
I am currently working on a web application project that focuses on enhancing user experience through a responsive design. My role involves developing and implementing automated test scripts to ensure the application's functionality, performance, and security. We are using tools like Selenium for UI testing and JMeter for performance testing. The project aims to deliver a high-quality product while maintaining a fast development cycle through continuous integration and testing.

Right Answer:
The effect of delivering a bug to the client can lead to decreased user satisfaction, potential loss of trust in the product, increased support costs, and possible financial implications if the bug affects critical functionality. It may also require additional resources for hotfixes or patches later.

Right Answer:
1. **Technical Risks**: Issues related to technology choices, integration, or performance.

2. **Project Management Risks**: Challenges in scheduling, resource allocation, or scope creep.

3. **Quality Risks**: Potential for defects or failures in the software that may affect user satisfaction.

4. **Operational Risks**: Risks arising from day-to-day operations, including process inefficiencies or system outages.

5. **Compliance Risks**: Failure to meet regulatory requirements or industry standards.

6. **Market Risks**: Changes in market conditions or customer preferences that could impact project success.

7. **Financial Risks**: Budget overruns or funding issues that could jeopardize project completion.

8. **Human Resource Risks**: Loss of key personnel or lack of necessary skills within the team.

Right Answer:
The core team in testing refers to a group of key individuals responsible for defining the testing strategy, ensuring quality standards, and overseeing the testing process throughout the software development lifecycle. This team typically includes test leads, test architects, and senior testers who collaborate to establish best practices and guide the testing efforts.