STLC and QA Testing

1. What are the models of SDLC?

The Software Development Life Cycle (SDLC) is a framework used by software developers and project managers to plan, design, build, test, deploy, and maintain software systems. There are several models of SDLC, each with its own set of stages and principles. Here, some of the most commonly used SDLC models are:

  1. Waterfall Model:

    • Phases: The Waterfall model divides the project into sequential phases that must be completed in a linear fashion. These phases include:

      • Requirements: Gather and document the project's requirements.

      • Design: Create the system architecture and detailed design.

      • Implementation: Code and develop the software based on the design.

      • Testing: Thoroughly test the software for defects and issues.

      • Deployment: Deploy the software to the production environment.

      • Maintenance: Provide ongoing support, bug fixes, and updates.

    • Rigidity: The model is rigid, and changes in requirements or design are challenging to accommodate once a phase is completed.

    • Suitability: Best suited for projects with well-defined and stable requirements, where changes are unlikely.

  2. Iterative Model:

    • Phases: The Iterative model retains the same phases as the Waterfall model but introduces iteration cycles, where each cycle includes all the phases.

    • Repetition: After each iteration, there's a review and an opportunity to refine and improve the product.

    • Flexibility: It's more flexible than the Waterfall model, making it suitable for projects where requirements are expected to evolve over time.

    • Suitability: Ideal for projects where the requirements are not entirely clear upfront or where stakeholders expect regular feedback.

  3. Agile Model:

    • Approach: Agile is a flexible and collaborative approach that focuses on delivering value to the customer through regular increments of working software.

    • Sprints: Work is divided into short development cycles called sprints (typically 2-4 weeks).

    • Iterative: Agile projects produce small, functional increments of the software in each sprint.

    • Flexibility: It highly values adaptability to changes and customer feedback throughout the project.

    • Suitability: Suitable for projects with changing or unclear requirements and where customer involvement is crucial.

  4. Scrum:

    • Roles: Scrum defines specific roles such as the Scrum Master (facilitator), Product Owner (representative of the customer), and Development Team.

    • Artifacts: Scrum uses artifacts like the Product Backlog (list of features) and Sprint Backlog (features planned for the current sprint).

    • Events: Key ceremonies include Sprint Planning (selecting work for the sprint), Daily Standup (short daily team meetings), Sprint Review (demonstrating the sprint's work), and Sprint Retrospective (reflection and process improvement).

  5. Kanban:

    • Visual Management: Kanban uses a visual board with columns representing stages of work (e.g., To Do, In Progress, Done).

    • Pull System: Work items are pulled into the "In Progress" column as team capacity allows.

    • Continuous Delivery: The focus is on maintaining a steady flow of work, with WIP limits preventing overloading the team.

  6. Spiral Model:

    • Phases: The Spiral model combines iterative development with risk analysis phases. It includes:

      • Planning: Define objectives and alternatives.

      • Risk Analysis: Evaluate potential risks.

      • Engineering: Develop and test.

      • Evaluation: Review the results and plan the next iteration.

    • Risk Management: Risk assessment is a central theme in this model, and each spiral addresses identified risks.

    • Gradual Expansion: Projects progress in a spiral pattern, with each loop representing a new iteration.

  7. V-Model (Validation and Verification Model):

    • Correlation: The V-Model correlates each development phase with a corresponding testing phase, ensuring that what is built matches the requirements.

    • Validation: It focuses on ensuring that the product meets the customer's needs by validating against the initial requirements.

    • Verification: Verification ensures that each development phase adheres to the requirements and design.

  8. Big Bang Model:

    • Minimal Planning: The Big Bang model typically involves minimal structured planning and documentation.

    • Informal: It is often used for small projects or proof-of-concept work.

    • Testing: Testing and validation usually occur after development is complete, which can be risky in terms of quality and meeting requirements.

  9. Rapid Application Development (RAD):

    • Prototyping: RAD focuses on rapid prototyping and quick feedback from users to refine the software.

    • Iterative: Development and refinement occur in multiple cycles, with each cycle improving the software based on user feedback.

    • Efficiency: The aim is to shorten the development time and rapidly deliver a functional product.

  10. Incremental Model:

    • Phases: The Incremental model divides the project into smaller parts, and each increment represents a portion of the complete system.

    • Addition: New functionality is added incrementally with each iteration or increment.

    • Testing: Testing occurs after each increment is added to ensure it meets the requirements and functions correctly.

  11. DevOps Model:

    • Collaboration: DevOps emphasizes collaboration between Development and Operations teams.

    • Automation: Automation of the software delivery pipeline is crucial for frequent and reliable releases.

    • Continuous Feedback: DevOps focuses on continuous improvement, monitoring, and quick response to changes in production.

Each SDLC model has its own strengths and weaknesses, and the choice of model depends on factors such as project requirements, timeline, budget, and organizational culture. Some organizations even adopt hybrid approaches or customize these models to best suit their specific needs and goals.


STLC stands for Software Testing Life Cycle. It is a systematic and well-defined process for testing software applications or systems to ensure their quality and reliability. STLC consists of a series of phases or stages that help organizations plan, design, execute, and manage software testing activities effectively. Each stage in the STLC has specific objectives, activities, and deliverables. Here are the typical stages of the Software Testing Life Cycle:

  1. Requirement Analysis: In this initial phase, the testing team works closely with the development team and stakeholders to understand the project requirements. The key objectives are to identify testable requirements, clarify ambiguities, and determine the scope of testing.

    • Activities:

      • Review and analyze project documentation, including requirements and design specifications.

      • Identify testable features and functions.

      • Create a traceability matrix to map test cases to requirements.

      • Identify test priorities and risks.

  2. Test Planning: In this stage, the testing team develops a comprehensive test plan that outlines the overall testing strategy, objectives, resources, schedule, and scope. The goal is to ensure that testing efforts align with project goals and requirements.

    • Activities:

      • Define the scope of testing.

      • Identify test objectives and success criteria.

      • Develop a test strategy.

      • Allocate resources and define roles and responsibilities.

      • Create a test schedule and estimate timelines.

      • Identify and prioritize test cases.

  3. Test Design: During this phase, test cases and test data are designed based on the test plan and requirements. The test design phase ensures that the testing process is well-structured and that all relevant scenarios are covered.

    • Activities:

      • Develop test scenarios and test cases.

      • Create test data and necessary test environment configurations.

      • Define test procedures and expected results.

      • Review and validate test cases.

  4. Test Environment Setup: A suitable testing environment is set up to mimic the production environment. This includes configuring hardware, software, networks, and databases to ensure that testing can be performed accurately.

    • Activities:

      • Install and configure necessary software and tools.

      • Set up test databases and servers.

      • Verify that the test environment matches the production environment as closely as possible.

  5. Test Execution: In this phase, the actual testing takes place. Testers execute test cases, report defects, and gather test results. It involves both manual and automated testing, as per the test design.

    • Activities:

      • Execute test cases according to the test plan.

      • Record test results and document any defects found.

      • Perform regression testing to ensure that new changes do not break existing functionality.

      • Continuously monitor and report testing progress.

  6. Defect Reporting and Tracking: During test execution, defects or issues are identified and reported to the development team. The testing team tracks these defects until they are resolved and verified.

    • Activities:

      • Report defects with detailed information, including steps to reproduce.

      • Prioritize and categorize defects.

      • Collaborate with the development team to resolve issues.

      • Verify fixed defects through retesting.

  7. Test Closure: Once the testing goals are met, and the software is deemed ready for release, the testing team concludes the testing phase. A test summary report is prepared to document the testing activities, results, and any outstanding issues.

    • Activities:

      • Prepare a test summary report.

      • Evaluate the overall testing process and assess the quality of the software.

      • Obtain necessary approvals for release.

  8. Post-Implementation Testing (Optional): This stage involves testing the software in the production environment after it has been deployed. It ensures that the software works as expected in the live environment.

    • Activities:

      • Perform post-implementation testing.

      • Monitor the software's performance and stability.

      • Address any issues that arise after deployment.

STLC is a critical part of the software development life cycle (SDLC) and helps organizations deliver high-quality software products to their customers. It ensures that testing is performed systematically and thoroughly at every stage of software development, reducing the likelihood of defects reaching the production environment.

3. As a test lead for a web based application, your manager has asked you to identify and explain the different risk factors that should be included in the test plan. can you provide a list of the potential risks and their explanations that you would include in the test plan?

when creating a test plan for a web-based application, it's crucial to identify and address potential risk factors to ensure comprehensive testing. Here's a list of potential risk factors and their explanations that you should consider including in your test plan:

  • Product risks – lack and/or stability of requirements, complexity of the product, etc. that eventually cause a mismatch in the end functionality and the needs of users and/or stakeholders’ expectations.

  • Project risks – issues caused due to the external dependencies, such contractual issues, delays on the contractor’s side, personal issues, non-work related constraints, and so on.

  • Process risks – issues related to planning and internal management of the project, including inaccurate estimates, delays, non-negotiable deadlines, underestimation of project complexity or other important aspects, etc.

The impact of these risks can affect both the user and the business with dire consequences such as financial impact from unhappy customers, penalties, legal liabilities, losing market share, losing customers, and tainted company reputation.

4. Your TL (Team Lead) has asked you to explain the difference between quality assurance (QA) and quality control (QC) responsibilites. while QC activities aim to identify defects in actual products. Your TL is interersted in processess that can prevent defects. How would you explain the distinction between QA and QC responsibilities to your boss?

Quality Assurance (QA): QA is a proactive and process-oriented approach aimed at preventing defects and ensuring that the processes used to develop a product or deliver a service are robust and reliable. It involves a set of planned and systematic activities that focus on process improvement, standards adherence, and the development of best practices. Here are some key points about QA responsibilities:

  1. Process Improvement: QA focuses on continuously improving processes to make them more efficient, effective, and capable of consistently producing high-quality results.

  2. Preventive: QA activities are proactive, aiming to identify and eliminate potential issues and sources of defects before they occur.

  3. Standards and Guidelines: QA establishes and enforces standards, guidelines, and quality management systems to ensure that work conforms to defined quality criteria.

  4. Training and Education: QA often includes training programs to educate team members about best practices, quality standards, and the importance of quality in the entire development or production process.

  5. Documentation: QA involves thorough documentation of processes, procedures, and quality standards, which can serve as a reference for continuous improvement.

Quality Control (QC): QC is a reactive and product-oriented approach focused on detecting defects and ensuring that the final product meets the predefined quality standards. It involves activities that verify and validate the output of a process. Here are some key points about QC responsibilities:

  1. Defect Detection: QC activities aim to identify and address defects, errors, or deviations in the final product or service.

  2. Post-Production: QC occurs after the product or service has been developed or produced, and it involves inspection, testing, and evaluation.

  3. Sampling: QC may involve inspecting a sample of the output, as it's often impractical to examine every single item.

  4. Corrective Action: When defects are found, QC typically involves corrective actions, such as rework or rejection of the non-conforming items.

  5. End-Product Focus: QC ensures that the final product or service meets the required quality standards, but it does not inherently improve the underlying processes.

In summary, QA is all about preventing defects by improving processes and adhering to standards, while QC is concerned with detecting defects in the end product. QA is a proactive approach that focuses on the entire process, whereas QC is a reactive approach focused on the product's quality at the end of the process. Both QA and QC are essential components of a comprehensive quality management system, and they work together to ensure the delivery of high-quality products or services.

5. Difference between manual testing and automation testing

Manual testing and automation testing are two approaches to software testing, each with its own advantages, disadvantages, and use cases. Here are the key differences between the two:

  1. Execution Process:

    • Manual Testing: In manual testing, test cases are executed by human testers who interact with the software's user interface, providing inputs, and verifying the outputs. Testers follow test scripts or test plans manually.

    • Automation Testing: Automation testing involves using automated scripts and testing tools to execute test cases. Test scripts are written to perform specific actions and checks automatically.

  2. Speed and Efficiency:

    • Manual Testing: Manual testing is relatively slower and less efficient, especially for repetitive and time-consuming test cases. It can be labor-intensive and prone to human errors.

    • Automation Testing: Automation testing is faster and more efficient for repetitive tasks. It can execute a large number of test cases quickly and consistently without fatigue or errors.

  3. Repetitive Testing:

    • Manual Testing: Manual testing is suitable for one-time or ad-hoc testing, but it can become tedious and error-prone when repetitive testing is required.

    • Automation Testing: Automation testing is ideal for repetitive testing, regression testing, and load testing, as the same tests can be run repeatedly without additional effort.

  4. Human Intervention:

    • Manual Testing: Requires human testers to make subjective judgments, explore the software, and provide feedback based on their domain knowledge and intuition.

    • Automation Testing: Lacks the ability to make subjective judgments or adapt to unexpected changes in the software. It relies on predefined scripts and test data.

  5. Initial Investment:

    • Manual Testing: Requires minimal initial investment as it mainly involves human testers and their expertise.

    • Automation Testing: Requires a higher initial investment in terms of tool selection, script development, and test environment setup.

  6. Maintenance:

    • Manual Testing: Test cases may need to be updated manually with changes in the software, which can be time-consuming and error-prone.

    • Automation Testing: Requires maintenance of test scripts whenever there are changes in the software, which can also be time-consuming but provides consistency.

  7. Suitability:

    • Manual Testing: Suitable for exploratory testing, usability testing, and scenarios where human judgment and creativity are essential.

    • Automation Testing: Best suited for regression testing, load testing, and cases where repeatability and consistency are critical.

  8. Test Coverage:

    • Manual Testing: Test coverage depends on the tester's ability to design comprehensive test cases and execute them accurately.

    • Automation Testing: Test coverage can be extensive as automated scripts can be designed to cover a wide range of scenarios.

  9. Adaptability:

    • Manual Testing: Testers can adapt to changes in the software and explore new areas without significant effort.

    • Automation Testing: Requires script modification when there are changes in the software's user interface or functionality.

In practice, a combination of manual and automation testing is often used to leverage the strengths of both approaches. Manual testing is valuable for exploratory testing, usability assessment, and scenarios requiring human judgment, while automation testing is efficient for repetitive tasks, regression testing, and load testing. The choice between manual and automation testing depends on the specific requirements of the project and the available resources.