What is Agile Testing? Process & Life Cycle

Agile testing, like agile itself, is not limited to a set of practices but requires a mindset shift towards improving quality at all the stages of a project/product. In today’s fast-paced digital landscape, software development teams face the challenge of delivering high-quality products at speed, without compromising on reliability or user satisfaction. And the primary reason for this struggle is the “Shunt Effect” caused at the testing phase.

Traditional project delivery cycle promotes “Testing” as a phase once the development is complete. In this case there is a delay in development, and since the timeline for most of the projects is fixed, testers face timeline crunch and will have to either compromise on the quality or work extra time to deliver a project. 

On the other hand, the agile environment promotes incremental and iterative development, in this case how do we understand “Testing life cycle in Agile?”. Well, this blog aims at explaining the same with details like:

• What is Agile testing life cycle?
• What are the principles involved in Agile testing?
• Strategies in Agile testing life cycle
• What is the shift needed in testing life cycle in agile?
• What is test life cycle in agile or testing cycle in agile?
• What is testing life cycle in agile methodology?
• What is STLC in agile?
• What are the testing phases in agile methodology or agile testing life cycle phases?
• What is agile defect life cycle?

What is Agile Testing?

Agile testing is a way of testing which promotes the principle of agile software development. In Agile, software is developed incrementally in small chunks called iterations or sprints. Agile testing aligns with this iterative approach by integrating testing throughout the entire development lifecycle, rather than keeping it as a separate phase at the end.

Unlike traditional waterfall development, where testing typically occurs after the completion of coding, Agile testing begins as soon as there is a working piece of software, even if it’s just a small feature. This allows for early validation of features and ensures that defects are identified and addressed adequately.

Agile testing is not just about finding defects, it’s about ensuring that the software meets business objectives, delivers value to the customer, and maintains a high level of quality throughout. By understanding Agile testing principles and practices, development teams can accelerate delivery, reduce risk, and ultimately build high quality software.

Features of Agile Testing

Agile is iterative and incremental. This means that the testers test each increment of coding as soon as it is finished. An iteration might be as short as one week, or as long as a month. The team builds and tests a little bit of code, making sure it works correctly, and then moves on to the next piece that needs to be built. Programmers never get ahead of the testers, because a story is not “done” until it has been tested. Let’s understand in detail the features or characteristics of the test life cycle in Agile.

Testing life cycle in agile methodology:

• Continuous Testing: Agile testing promotes continuous integration of code changes and continuous testing throughout the development process. Automated tests are integrated into the build pipeline, allowing for quick check on quality of each code change.
• Iterative and Incremental Approach: Testing occurs in short iterations or sprints, with each iteration delivering a working software increment. This iterative approach enables early validation of features and capturing the bugs.
• Collaboration and Communication: Agile testing promotes close collaboration between developers, testers, product owners, and other stakeholders. Team members work together to define acceptance criteria, clarify requirements, and prioritize testing activities.
• Left Shift in Testing: Test-Driven Development is a practice commonly used in Agile development, where tests are written before the code is implemented. This approach helps drive the development process by clarifying requirements and validating functionality early on.
• User Stories and Acceptance Criteria: Testing in Agile is often based on user stories, which describe desired functionality from the perspective of an end user. Acceptance criteria are defined for each user story to establish clear expectations for when the functionality is considered complete.
• Frequent Regression Testing: With each iteration, Agile teams perform regression testing to ensure that existing functionality has not been  affected by new changes. Automated regression tests are particularly valuable for quickly verifying the integrity of the software after each update.
• Prioritize Customer Feedback: Agile testing prioritizes  seeking feedback early and continuously. This feedback loop helps validate assumptions, capture issues, and guide prioritization of features to deliver maximum value to the customer.
• Adapt to Changes: Agile testing is highly adaptable to changing requirements and priorities. Testing strategies and priorities can be adjusted dynamically based on feedback, risks, and  changing business needs.

Agile Testing Principles

Agile testing principles are the key pillars in understanding or implementing testing life cycle in agile methodology, these principles guide testing mindset shift and create opportunities of deriving necessary practices. 

• Provide Continuous Feedback – Feedback plays a big part in any agile team. The tester’s traditional role of “defect gate keeper and user focused” makes it important to an agile team. In agile defect life cycle, one of the agile tester’s most important contributions is helping the product owner or customer write requirements for each story in the form user centric  tests. The tester then works together with the development team to convert those requirements into executable tests. Testers, programmers, and other team members work to run these tests early to arrest the bugs early and get feedback

• Deliver value to the customer – Agile testing prioritizes delivering value to the customer. Testing activities are driven by customer needs and feedback, with a focus on validating functionality, usability, and overall user satisfaction.

• Enable Face to Face Conversation – Agile testers see each story or theme from the customer’s point of view but also understand technical aspects and limitations related to implementing features. They can help customers and developers achieve a common language. Business people and software people often speak different languages. They have to find some common ground in order to work together successfully. Any time there is a question about how a feature should work or what an inter- face should look like, the tester can pull in a programmer and a business expert to talk about it.

• Have Courage – Courage is an important trait of an agile team and practices such as test automation and continuous integration allow the team to practice this value. The developers have the courage to make changes and refactor the code because they have the safety net of an automated regression suite. While this is created by the testing team, they also must have ample courage to make changes, suggest and improvise

• Keep it Simple – Agile testing favors simple, lightweight processes and documentation. Test plans, test cases, and other testing artifacts are kept lean and focused, with an emphasis on delivering value rather than adhering to rigid processes.

• Practice Continuous Improvement – Agile encourages a culture of continuous improvement, where teams retrospect on their testing practices, identify areas for improvements, and experiment with new approaches. By continuously learning and adapting, teams can make their testing practices and efforts lean and deliver value faster

• Respond to Change – Responding to change is a key value for agile practitioners, but we’ve found that it’s one of the most difficult concepts for testers. Continuously changing requirements are a tester’s nightmare.As long as we keep talking to the customer, we can handle changes like that because we are working at the same pace with the rest of team.Some agile teams try to prepare in advance of the next iteration, perhaps by writing high-level test cases, capturing business conditions, or documenting user behavior.

• Self Organize – The agile tester is part of a self-organizing agile team. When programmers, system administrators, analysts, database experts, and the customer team think continuously about testing and test automation, testers enjoy a whole new perspective. Automating tests is hard, but it is much easier when you have the whole team working together. Any testing issue is easier to address when you have people with multiple skill sets and multiple perspectives attacking it.

• Focus on People – Agile testing promotes collaboration between developers, testers, product owners, and other stakeholders. Close communication and collaboration facilitate shared common understanding of requirements, priorities, and testing goals, leading to more effective testing outcomes.

• Enjoy – Working in a team where everyone collaborates, where you are engaged in the project from start to finish, where business stakeholders work together with the development team, where the whole team takes responsibility for quality and testing, is an ideal environment for a tester when compared to traditional ways where testing is just a phase of it.

Agile Testing Methodologies

When it comes to practices in the agile test life cycle, teams use one of many frameworks to ensure quality. All these frameworks enable the teams to adapt to principles of agile testing. Some of the frameworks used in testing life cycle in agile methodology include:

• Test-Driven Development (TDD) –  is a software development approach that emphasizes writing tests before writing the actual code. It follows a cycle of writing a failing test, writing the minimum amount of code necessary to pass the test, and then refactoring the code to improve its design while ensuring that all tests still pass.
• Behavior Driven Development (BDD) – Behavior-Driven Development (BDD) is a software development methodology that focuses on defining and verifying the behavior of a system from the perspective of its stakeholders. At its core, BDD involves writing executable specifications called “scenarios” or “user stories” that describe the expected behavior of a feature or component in a language that is understandable by both technical and non-technical stakeholders. These scenarios are typically written using a structured format known as Given-When-Then (GWT) format.
• Extreme Programming (XP) – Is an Agile software development framework that promotes iterative development, continuous feedback, and flexible adaptation to changing requirements. It promotes practices such as test-driven development (TDD), pair programming, continuous integration, and frequent releases to deliver high-quality software increments. XP prioritizes customer satisfaction, teamwork, and simplicity in order to maximize productivity and minimize waste.
• Exploratory Testing – Exploratory testing is an approach to software testing where testers design and execute tests in parallel, exploring the application without predefined test cases or scripts. Testers rely on their domain knowledge, intuition, and creativity to find defects, observe system behavior, and evaluate user experience.
• Dynamic Software Development Method (DSDM) – Incorporates principles such as prioritizing the business need, delivering iteratively, collaborating continuously, and maintaining a focus on quality throughout the project lifecycle. It is particularly suited for projects where requirements may evolve and change rapidly.
• Session-Based Testing (SBT) – Is a method of exploratory testing that structures exploratory testing into manageable time-boxed sessions. In SBT, testers conduct testing sessions typically ranging from 60 to 120 minutes, focusing on specific test objectives or areas of the application.
  
• Acceptance Test-Driven Development (ATDD) – Is a practice within Agile software development that involves collaboratively defining acceptance criteria for user stories or features before implementation. ATDD encourages collaboration between developers, testers, and business stakeholders to ensure a shared understanding of requirements and expectations. Once acceptance criteria are defined, automated acceptance tests are created to verify that the software meets these criteria.

Agile Testing Strategies

Agile testing can be deployed at 4 stages of a project/product delivery. They are as shown in the picture below.

Iteration/Sprint 0

During the initial stage / initiation phase or iteration 0, teams perform initial setup tasks. It includes identifying resources for testing, finalizing and setup of testing tools, etc. The following steps are set to achieve in Iteration 0:

• Establishing a business case for the project
• Establish the boundary conditions and the project scope
• Outline the key requirements and use cases that will drive the design trade-offs
• Outline one or more candidate architectures
• Identifying the risk
• Cost estimation and prepare a preliminary project

Construction Iteration

This is the second phase of a project, where most of the work is done. These are the iterations where the software is being developed through incremental approach. Testing in this phase can be looked upon at two different ways, 

• Confirmatory testing – also known as validation testing or functional testing, is a type of software testing that verifies that the software behaves as expected based on predefined requirements, specifications, or user stories. Some of the practices include
  • Validating the user story by predefined test cases 
  • Verification of acceptance criteria by the product team
  • Compliance and NFR validation by the testing team 
  • Automation of functional scprits 
  • Development team writing unit testing
• Investigative Testing – Is an agile testing way in which teams try to arrest a problem missed by confirmatory testing. Like a system behavior when it is integrated with other systems. Some of the investigative testing practices include:
  • Integration testing 
  • Security and compliance testing
  • Load and performance testing
  • Stress testing 

Release End game 

The next agile testing life cycle phase includes full system testing and acceptance testing. In order to finish your final testing stage without any obstacles, you should have to test the product more rigorously while it is in construction iterations. During the end game, testers will be working on its defect stories.

• Training end-users.
• Support people and operational people.
• Marketing of the product release.
• Back-up, Archival and restoration.
• Finalization of the system and user manual documentation.

Production

The last agile testing life cycle phase. The product is finalized in this stage after the removal of all defects and issues raised. Basically consists of activities like:

• Testing the system in Staging / Pre Prod systems 
• Testing the systems after performance tweaking 
• Load and stress testing bug fixes retesting

Agile Testing Quadrants

The Agile testing quadrants provide a framework for separating different types of testing activities based on their purpose and scope within Agile software development. Each quadrant represents different types of testing. The image below depicts the quadrants and associated type of testing.

Quadrant 1

Technology-Facing Tests (Unit Tests, Component Tests): Tests in this quadrant focus on validating the behavior of individual work items  or units of code. These tests are typically automated and executed frequently by developers as part of the development process. Examples include unit tests, component tests, and API tests.

Quadrant 2

Business-Facing Tests (Acceptance Tests, Functional Tests): Tests in this quadrant focus on validating the behavior of the system from a business or end-user perspective. These tests verify that the software meets mentioned requirements, user stories, or acceptance criteria. Business-facing tests are typically automated and executed as part of the continuous integration process. Examples include acceptance tests, functional tests, and user interface (UI) tests. 

Quadrant 3

Business-Facing Tests (Exploratory Testing, Scenario Testing): Tests in this quadrant focus on exploring the system to uncover defects, evaluate usability, and validate assumptions. These tests are typically performed manually by testers and may involve ad hoc testing, exploratory testing, or scenario-based testing.

Quadrant 4

Technology-Facing Tests (Performance Testing, Security Testing): Tests in this quadrant focus on validating non-functional aspects of the system, such as performance, scalability, reliability, and security. These tests may involve stress testing, load testing, security testing, and other types of non-functional testing.

Agile Testing Life Cycle

The Agile testing lifecycle is a continuous  process that occurs throughout the entire Agile software development lifecycle. It consists of various testing activities focussing on ensuring the delivery of high-quality software increments that meet customer needs and expectations. While the specifics may vary depending on the Agile methodology used (e.g., Scrum, Kanban, Extreme Programming), the Agile testing life cycle typically includes the following phases (Testing phases in agile methodology):

• Test Planning: In this initial phase, the testing strategy and approach for the project are defined. This includes identifying testing objectives, scope, priorities, risks, and constraints like environment, resources and timelines.
• Requirement Analysis: During this phase, testing team collaborate with business stakeholders, product owners, and developers to understand project requirements and user stories. Testers help clarify acceptance criteria, identify testable features, and ensure that requirements are testable and measurable.
• Test Design: In this phase, test cases, test scenarios, and test data are designed based on project requirements and acceptance criteria. Testers create both functional and non-functional test cases to validate the behavior of the software and address quality attributes such as usability, performance, and security.
• Test Execution: Test execution involves running test cases and scenarios to validate that the software behaves as expected and meets specified requirements. Testers perform both manual and automated testing activities, executing functional tests, regression tests, integration tests etc.
• Defect Management: Throughout the Agile testing life cycle, defects and issues discovered during testing are logged, tracked, and managed. Testers collaborate with developers and other stakeholders to prioritize and resolve defects promptly, ensuring that issues are addressed in a timely manner.
• Continuous Integration and Deployment: Agile teams practice continuous integration, where code changes are integrated into the main codebase frequently, typically multiple times per day. Automated tests are executed as part of the continuous integration process to validate that new changes do not introduce regressions or defects.
• Feedback and Retrospective: Agile testing emphasizes continuous improvement, with regular feedback loops and retrospectives to reflect on testing practices, identify areas for improvement, and make adjustments to testing strategies and processes.

Agile Test Plan

Testing life cycle in agile methodology promotes test plan to be a living document that evolves throughout the project as requirements change, feedback is received, and testing activities progress.Unlike traditional test plans, which are often detailed and comprehensive, Agile test plans are flexible and adaptable, reflecting the iterative and incremental nature of Agile development. Some of the aspects to include in a test plan include,

• Provides an overview of the purpose, scope, and objectives of the test plan
• Clearly defines the goals and objectives of testing activities within the Agile project like functional validation, ensuring quality to the value delivery etc
• Outlines the overall approach and strategy for testing within the Agile project. This includes decisions regarding test automation, testing techniques, test coverage
• Defines the scope of testing activities, including the features, functionalities, and components to be tested
• The testing process and lifecycle within the Agile project, including how testing activities will be integrated into development iterations or sprints
• Types of testing to be performed, such as functional testing, non-functional testing, integration testing, and regression testing
• Level of test coverage expected for each type of testing.
• The testing environment, including hardware, software, tools, and resources required for testing activities
• Test data required for testing activities, including any sample data, test scenarios, or test cases to be used during testing
• Mentioning potential risks, assumptions, and dependencies that may impact testing activities or outcomes
• Defines the roles and responsibilities of team members involved in testing, including testers, developers, product owners, and other stakeholders
• Specifies the process for reviewing, approving, and updating the test plan throughout the project lifecycle

Benefits of Agile Testing

Below are a few benefits teams reap in agile testing cycles, 

• Agile testing helps get new features to users quickly because of incremental testing 
• It ensures fewer bugs and a more stable product with early detection of bugs
• Agile testing emphasis on less documentation reducing efforts 
• Agile testing encourages learning and refining processes over time for even better results.
• With in-sprint testing and automation – agile testing allows teams to respond to changes easily.
• Reduces manual effort and cost with focus on automation 

Challenges During Agile Testing

Here are a few challenges testing teams face in general: 

• Testing needs to keep up with the rapid pace of development iterations, often leading to pressure to complete testing within tight deadlines.
• Agile projects frequently encounter evolving requirements, making it challenging to define and execute test cases effectively
• Limited availability of skilled testers, testing tools, and testing environments can hinder the efficiency and effectiveness of testing efforts.
• Coordinating testing across multiple teams, components, and third-party systems can be complex, leading to integration challenges and delays.
• Ensuring comprehensive test coverage across all features and functionalities within short iterations can be difficult,
• While test automation is essential for Agile testing to achieve speed and efficiency, it also presents challenges such as maintenance overhead
• As new features are added and existing functionality is modified in each iteration, regression testing becomes crucial to ensure that no unintended side effects or regressions occur. However, conducting regression testing efficiently within short iterations can be challenging
• Scaling Agile testing to large or distributed teams, complex projects, or organizations with diverse stakeholders and dependencies can pose significant challenges in terms of coordination, alignment, and synchronization of testing activities.

Risks During Agile Testing

In Agile testing life cycle there are certain risks which the teams need to tackle with proper strategies, some of them include:

• Agile projects often deal with evolving requirements, which can lead to incomplete or ambiguous requirements. This can result in incomplete or incorrect testing and ultimately impact the quality of the software.
• Over dependence on manual testing without adequate automation can lead to bottlenecks, increased testing effort, and limited test coverage
• Insufficient test automation can slow down testing efforts and increase the risk of human error
• Dependencies on external systems, third-party libraries, or services can introduce risks to testing
• Technical debt, such as poor code quality or lack of automated tests, can make testing more challenging
• As new features are added and existing functionality is modified in each iteration, there is a risk of introducing regressions
• Limited availability of skilled testers, testing tools, or testing environments can pose a risk to the effectiveness and efficiency of testing efforts
• Changes in requirements or priorities during the development process, known as scope creep, can affect the testing effort

Can companies get help from consulting firms for testing?

Certainly. By engaging Agile strategy consulting firms for testing services, organizations can leverage subject matter expertise, gain access to resources and tools, and speed their journey towards achieving higher quality software and improved testing efficiency.Here are a few ways in which consulting firms add value:  

• Agile Consulting firms can assist companies in developing testing strategies and plans tailored to their specific needs 
• They can help companies optimize their testing processes by recommending improvements, streamlining workflows, and implementing industry-leading methodologies
• Can provide guidance on selecting the right testing tools and technologies to support the testing process
• Agile Consulting and transformation company often have expertise in test automation and can help companies automate their testing efforts to improve efficiency, increase test coverage, and accelerate release cycles
• May offer specialized testing services in areas such as performance testing, security testing, accessibility testing, mobile testing
• Agile Consulting firms can assist companies in establishing quality assurance practices and governance frameworks
• They often offer training programs and workshops to help organizations build testing skills and capabilities

Conclusion

Agile testing is not just a set of techniques and practices, rather a mindset very well bound by agile principles. By integrating testing activities seamlessly into Agile frameworks like Scrum, Kanban, or Extreme Programming, teams can ensure that quality is not a by-product but a way of working from the very beginning. 

The Agile testing lifecycle promotes collaboration, adaptability, and continuous improvement, enabling teams to deliver high-quality software increments that meet customer needs and expectations. 

As organizations adapt to Agile ways of working, they can reap the full potential of Agile testing to speed up delivery, mitigate risks, and deliver higher value to the customers. 

We end this blog on “What is Agile Testing? Process and Life Cycle” by Benzne Agile transformation roadmap leadership consulting.Benzne Agile transformation and consulting on this note and we hope this helped you understand the nitty gritties of Agile testing and given a direction in implementing it as well. Please write to consult@benzne.com for any feedback or suggestions. We would be glad to support your agile transformation plan and solve any bottlenecks you may have while adopting agile ways of working.

 

Frequently Asked Questions

1. What is the test cycle in agile or STLC in agile?

The Agile testing lifecycle is a continuous  process that occurs throughout the entire Agile software development lifecycle. It consists of various testing activities focussing on ensuring the delivery of high-quality software increments that meet customer needs and expectations. Below is a typical test life cycle in agile:

• Test Planning: In this initial phase, the testing strategy and approach for the project are defined. This includes identifying testing objectives, scope, priorities, risks, and constraints like environment, resources and timelines.
• Requirement Analysis: During this phase, testing team collaborate with business stakeholders, product owners, and developers to understand project requirements and user stories. Testers help clarify acceptance criteria, identify testable features, and ensure that requirements are testable and measurable.
• Test Design: In this phase, test cases, test scenarios, and test data are designed based on project requirements and acceptance criteria. Testers create both functional and non-functional test cases to validate the behavior of the software and address quality attributes such as usability, performance, and security.
• Test Execution: Test execution involves running test cases and scenarios to validate that the software behaves as expected and meets specified requirements. Testers perform both manual and automated testing activities, executing functional tests, regression tests, integration tests etc
• Defect Management: Throughout the Agile testing life cycle, defects and issues discovered during testing are logged, tracked, and managed. Testers collaborate with developers and other stakeholders to prioritize and resolve defects promptly, ensuring that issues are addressed in a timely manner.
• Continuous Integration and Deployment: Agile teams practice continuous integration, where code changes are integrated into the main codebase frequently, typically multiple times per day. Automated tests are executed as part of the continuous integration process to validate that new changes do not introduce regressions or defects.
• Feedback and Retrospective: Agile testing emphasizes continuous improvement, with regular feedback loops and retrospectives to reflect on testing practices, identify areas for improvement, and make adjustments to testing strategies and processes.

2. What is an agile life cycle?

Agile life cycle refer to the phases involved in an agile project or product delivery. Below are the phases in agile life cycle, 

• Initiation / Discovery  – This phase involves defining the project vision, goals, and scope
• Planning: Agile planning is iterative and dynamic. Instead of creating a comprehensive plan upfront, Agile teams engage in iterative planning sessions to define the scope of the next iteration or sprint
• Execution: This phase is where development work happens.
• Review and Retrospective: At the end of each sprint, the team conducts a sprint review to demonstrate the completed work to stakeholders and gather feedback. Additionally, they hold a sprint retrospective to reflect on the sprint process and identify opportunities for improvement
• Monitoring and Adaptation: Throughout the Agile lifecycle, teams continuously monitor progress and adapt their approach based on feedback and changing requirements
• Closure: Once the project goals have been achieved or the product reaches the end of its lifecycle

3. What is the QA testing life cycle?

Testing life cycle in agile describes the various stages and activities involved in ensuring the quality of a software product. The stages of testing cycle in agile include, 

• Requirement Analysis: In this initial stage, QA testers collaborate with stakeholders to understand the project requirements thoroughly
• Test Planning: QA testers create a test plan outlining the testing approach
• Test Design: Testers design test cases based on the requirements
• Test Environment Setup: QA teams set up the testing environment, including hardware, software, networks, and test data
• Test Execution: Testers execute the designed test cases according to the test plan
• Defect Reporting and Tracking : During test execution, testers identify defects or issues in the software and report them using a defect tracking system
• Test Closure: Once testing is complete, QA teams conduct a final round of testing to ensure that all requirements have been met
• Post-Release Testing and Maintenance: After the software is released, QA teams may continue testing in production or conduct post-release testing to monitor for any issues 

4. What are the 4 stages of testing?

The four main stages of testing in software development are:

• Unit Testing: This is the first stage of testing where developers write and execute unit tests to verify the correctness of their code. 
• Integration Testing: In this stage, individual units or components of the software are combined and tested as a group. 
• System Testing: System testing involves testing the entire software system as a whole. It evaluates its specified requirements and validates its functionality, performance, reliability
• Acceptance Testing: Acceptance testing is the final stage of testing and is conducted to validate that the software meets the business requirements and is ready for deployment. 

5. What is the agile test approach?

When it comes to practices in the agile test life cycle, teams use one of many frameworks to ensure quality. All these frameworks enable the teams to adapt to principles of agile testing. Some of the frameworks in test life cycle in agile are:

• Test-Driven Development (TDD) –  is a software development approach that emphasizes writing tests before writing the actual code. It follows a cycle of writing a failing test, writing the minimum amount of code necessary to pass the test, and then refactoring the code to improve its design while ensuring that all tests still pass. 
• Behavior Driven Development (BDD) – Behavior-Driven Development (BDD) is a software development methodology that focuses on defining and verifying the behavior of a system from the perspective of its stakeholders. At its core, BDD involves writing executable specifications called “scenarios” or “user stories” that describe the expected behavior of a feature or component in a language that is understandable by both technical and non-technical stakeholders. These scenarios are typically written using a structured format known as Given-When-Then (GWT) syntax
• Extreme Programming (XP) – Is an Agile software development framework that promotes iterative development, continuous feedback, and flexible adaptation to changing requirements. It promotes practices such as test-driven development (TDD), pair programming, continuous integration, and frequent releases to deliver high-quality software increments. XP prioritizes customer satisfaction, teamwork, and simplicity in order to maximize productivity and minimize waste.
• Exploratory Testing – Exploratory testing is an approach to software testing where testers design and execute tests in parallel, exploring the application without predefined test cases or scripts. Testers rely on their domain knowledge, intuition, and creativity to find defects, observe system behavior, and evaluate user experience.
• Dynamic Software Development Method (DSDM) – Incorporates principles such as prioritizing the business need, delivering iteratively, collaborating continuously, and maintaining a focus on quality throughout the project lifecycle. It is particularly suited for projects where requirements may evolve and change rapidly.
• Session-Based Testing (SBT) – Is a method of exploratory testing that structures exploratory testing into manageable time-boxed sessions. In SBT, testers conduct testing sessions typically ranging from 60 to 120 minutes, focusing on specific test objectives or areas of the application.
• Acceptance Test-Driven Development (ATDD) – Is a practice within Agile software development that involves collaboratively defining acceptance criteria for user stories or features before implementation. ATDD encourages collaboration between developers, testers, and business stakeholders to ensure a shared understanding of requirements and expectations. Once acceptance criteria are defined, automated acceptance tests are created to verify that the software meets these criteria.