Agile SDLC model is a combination of iterative and incremental

process models with focus on process adaptability and customer

satisfaction by rapid delivery of working software product. Agile
Methods break the product into small incremental builds. These
builds are provided in iterations. Each iteration typically lasts from
about one to three weeks. Every iteration involves cross
functional teams working simultaneously on various areas like −

 Planning
 Requirements Analysis
 Design
 Coding
 Unit Testing and
 Acceptance Testing.

At the end of the iteration, a working product is displayed to the

customer and important stakeholders.

What is Agile?
Agile model believes that every project needs to be handled
differently and the existing methods need to be tailored to best
suit the project requirements. In Agile, the tasks are divided to
time boxes (small time frames) to deliver specific features for a
release.

Iterative approach is taken and working software build is

delivered after each iteration. Each build is incremental in terms
of features; the final build holds all the features required by the
customer.

Here is a graphical illustration of the Agile Model −

The Agile thought process had started early in the software
development and started becoming popular with time due to its
flexibility and adaptability.

The most popular Agile methods include Rational Unified Process

(1994), Scrum (1995), Crystal Clear, Extreme Programming
(1996), Adaptive Software Development, Feature Driven
Development, and Dynamic Systems Development Method
(DSDM) (1995). These are now collectively referred to as Agile
Methodologies, after the Agile Manifesto was published in 2001.

Following are the Agile Manifesto principles −

 Individuals and interactions − In Agile development, self-

organization and motivation are important, as are
interactions like co-location and pair programming.
 Working software − Demo working software is considered
the best means of communication with the customers to
understand their requirements, instead of just depending on
documentation.
 Customer collaboration − As the requirements cannot be
gathered completely in the beginning of the project due to
various factors, continuous customer interaction is very
important to get proper product requirements.
 Responding to change − Agile Development is focused on
quick responses to change and continuous development.

Agile Model - Pros and Cons

Agile methods are being widely accepted in the software world
recently. However, this method may not always be suitable for all
products. Here are some pros and cons of the Agile model.

The advantages of the Agile Model are as follows −

 Is a very realistic approach to software development.

 Promotes teamwork and cross training.
 Functionality can be developed rapidly and demonstrated.
 Resource requirements are minimum.
 Suitable for fixed or changing requirements
 Delivers early partial working solutions.
 Good model for environments that change steadily.
 Minimal rules, documentation easily employed.
  Enables concurrent development and delivery within an
overall planned context.
 Little or no planning required.
 Easy to manage.
 Gives flexibility to developers.

The disadvantages of the Agile Model are as follows −

 Not suitable for handling complex dependencies.

 More risk of sustainability, maintainability and extensibility.
 An overall plan, an agile leader and agile PM practice is a
must without which it will not work.
 Strict delivery management dictates the scope, functionality
to be delivered, and adjustments to meet the deadlines.
 Depends heavily on customer interaction, so if customer is
not clear, team can be driven in the wrong direction.
 There is a very high individual dependency, since there is
minimum documentation generated.
 Transfer of technology to new team members may be quite
challenging due to lack of documentation.
Steps in the Agile Model
The agile model is a combination of iterative and incremental
process models. The steps involve in agile SDLC models are:
 Requirement gathering
 Design the Requirements
 Construction / Iteration
 Testing / Quality Assurance
 Deployment
 Feedback

1. Requirement Gathering:- In this step, the development

team must gather the requirements, by interaction with the
customer. development team should plan the time and effort
needed to build the project. Based on this information you can
evaluate technical and economical feasibility.
2. Design the Requirements:- In this step, the development
team will use user-flow-diagram or high-level UML diagrams to
show the working of the new features and show how they will
apply to the existing software. Wireframing and designing user
interfaces are done in this phase.
3. Construction / Iteration:- In this step, development team
members start working on their project, which aims to deploy a
working product.
4. Testing / Quality Assurance:- Testing involves Unit
Testing, Integration Testing, and System Testing. A brief
introduction of these three tests is as follows:
5. Unit Testing:- Unit testing is the process of checking small
pieces of code to ensure that the individual parts of a program
work properly on their own. Unit testing is used to test individual
blocks (units) of code.
 Integration Testing:- Integration testing is used to
identify and resolve any issues that may arise when
different units of the software are combined.
 System Testing:- Goal is to ensure that the software
meets the requirements of the users and that it works
correctly in all possible scenarios.
5. Deployment:- In this step, the development team will deploy
the working project to end users.
6. Feedback:- This is the last step of the Agile Model. In this,
the team receives feedback about the product and works on
correcting bugs based on feedback provided by the customer.
The time required to complete an iteration is known as a Time
Box. Time-box refers to the maximum amount of time needed to
deliver an iteration to customers. So, the end date for an
iteration does not change. However, the development team can
decide to reduce the delivered functionality during a Time-box if
necessary to deliver it on time. The Agile model’s central
principle is delivering an increment to the customer after each
Time-box.

Principles of Agile −

While Agile itself is more of an ideology or manifesto, there are different form
of implementation of the same as explained above. However, one look at
those methodologies and one can figure out that all of them have a common
skeleton or some basic ideas over which all those methodologies are based
on. Based on the Agile manifesto, there are a total of 12 principles or
guideline which all the agile methodologies standby. Which are −
 Agile promotes early and continuous delivery of valuable
software. That means while customer satisfaction is one of the major
focus in Agile, clients always look for faster delivery and early or on
time delivery is a way to keep your customers happy as at the end of
the day, they mainly care about the end product rather than the overall
process.
 Being flexible about change at any point of development. One
of agile’s primary focus is customer satisfaction and agile is all about
customer’s input and involvement throughout the process including
integrating requirement changes at any point of time during the
development.
 Working on frequent and short deliveries throughout the
development process. Those deliveries can be weekly or monthly
based depending upon the cycle/ sprint duration in order to keep the
client updated periodically regarding present status of development.
 Agile promotes transparency between business people and
developers and requires them to work together which helps in
better coordination, risk management as well as understanding of the
product development flow both technically as well as from a business
point of view.
 Agile advocates for motivating individuals in the team. By
providing a better productive environment and providing them with all
the support, motivation and respect, there will be a team that is
motivated and trust each other which is highly effective in getting
better productivity.
 While technical advancement has gifted us with many alternative ways
to communicate, agile believes in face to face communication as
the most effective way to communicate between and to
development team.
 Agile focuses on through planning and designing in order to get a clear
understanding of the user requirement. Agile motivates continuous
attention towards effective designing and technical
excellence through following optimal code standard. It can be done
through regular code inspection on technical reviews and refactoring
based on the reviews at regular intervals.
 Agile promotes sustainable development. The developers, users
and sponsors should work together in order to ship out delivery at a
constant pace. As requirement changes as well as blockages during the
 development process are bound to happen, the whole team must work
together so that the delivery process is followed indefinitely.
 Working software is the primary measure of progress. In simple
terms, none of the planning, designing or overall development process
matters if the end product is not in working condition. The properly
working end software product is what the success of an agile process
depends on.
 Simplicity—the art of maximizing the amount of work not done
—is essential. In simple terms, to extract maximum result with less
hard work. Agile promotes removing unnecessary tasks and prioritizing
activities can have maximum impact with less and effective work done.
 The best architectures, requirements, and designs emerge
from self-organizing teams. Agile advocates encouraging and
appreciating motivated individuals in a team, who are passionate about
the whole development process, take ownership of their tasks and
share ideas among each other through effective communication. This
results in having a team of motivated and highly valuable team players
with a sense of ownership working together to provide better
productivity.
 At regular intervals, the team reflects on how to become more
effective, then tunes and adjusts its behavior
accordingly. There is always a scope for change and improvement.
Agile promotes team members should focus on self –improvement.
They should do regular analysis and work on improving the overall
delivery or the development proces
Agile Software Testing
Last Updated : 24 May, 2023



Agile Testing is a type of software testing that follows the
principles of agile software development to test the software
application. All members of the project team along with the
special experts and testers are involved in agile testing. Agile
testing is not a separate phase and it is carried out with all the
development phases i.e. requirements, design and coding, and
test case generation. Agile testing takes place simultaneously
throughout the Development Life Cycle. Agile testers participate
in the entire development life cycle along with development team
members and the testers help in building the software according
to the customer requirements and with better design and thus
code becomes possible. The agile testing team works as a single
team towards the single objective of achieving quality. Agile
Testing has shorter time frames called iterations or loops. This
methodology is also called the delivery-driven approach because
it provides a better prediction on the workable products in less
duration time.
 Agile testing is an informal process that is specified as a
dynamic type of testing.
 It is performed regularly throughout every iteration of the
Software Development Lifecycle (SDLC).
  Customer satisfaction is the primary concern for agile test
engineers at some stage in the agile testing process.
Features of Agile Testing
Some of the key features of agile software testing are:
 Simplistic approach: In agile testing, testers perform
only the necessary tests but at the same time do not
leave behind any essential tests. This approach delivers a
product that is simple and provides value.
 Continuous improvement: In agile testing, agile testers
depend mainly on feedback and self-learning for
improvement and they perform their activities efficiently
continuously.
 Self-organized: Agile testers are highly efficient and
tend to solve problems by bringing teams together to
resolve them.
 Testers enjoy work: In agile testing, testers enjoy their
work and thus will be able to deliver a product with the
greatest value to the consumer.
 Encourage Constant communication: In agile testing,
efficient communication channels are set up with all the
stakeholders of the project to reduce errors and
miscommunications.
 Constant feedback: Agile testers need to constantly
provide feedback to the developers if necessary.
Agile Testing Principles
 Shortening feedback iteration: In Agile Testing, the
testing team gets to know the product development and
its quality for each and every iteration. Thus continuous
feedback minimizes the feedback response time and the
fixing cost is also reduced.
 Testing is performed alongside Agile testing is not a
different phase. It is performed alongside the
development phase. It ensures that the features
implemented during that iteration are actually done.
Testing is not kept pending for a later phase.
 Involvement of all members: Agile testing involves
each and every member of the development team and
the testing team. It includes various developers and
experts.
 Documentation is weightless: In place of global test
documentation, agile testers use reusable checklists to
suggest tests and focus on the essence of the test rather
 than the incidental details. Lightweight documentation
tools are used.
 Clean code: The defects that are detected are fixed
within the same iteration. This ensures clean code at any
stage of development.
 Constant response: Agile testing helps to deliver
responses or feedback on an ongoing basis. Thus, the
product can meet the business needs.
 Customer satisfaction: In agile testing, customers are
exposed to the product throughout the development
process. Throughout the development process, the
customer can modify the requirements, and update the
requirements and the tests can also be changed as per
the changed requirements.
 Test-driven: In agile testing, the testing needs to be
conducted alongside the development process to shorten
the development time. But testing is implemented after
the implementation or when the software is developed in
the traditional process.
Agile Testing Methodologies
Some of the agile testing methodologies are:
1. Test-Driven Development (TDD): TDD is the software
development process relying on creating unit test cases
before developing the actual code of the software. It is an
iterative approach that combines 3 operations,
programming, creation of unit tests, and refactoring.
2. Behavior Driven Development (BDD): BDD is agile
software testing that aims to document and develop the
application around the user behavior a user expects to
experience when interacting with the application. It
encourages collaboration among the developer, quality
experts, and customer representatives.
3. Exploratory Testing: In exploratory testing, the tester
has the freedom to explore the code and create effective
and efficient software. It helps to discover the unknown
risks and explore each aspect of the software
functionality.
Agile Testing Life Cycle
The agile testing life cycle has 5 different phases:
1. Impact Assessment: This is the first phase of the agile
testing life cycle also known as the feedback phase
where the inputs and responses are collected from the
 users and stakeholders. This phase supports the test
engineers to set the objective for the next phase in the
cycle.
2. Agile Testing Planning: In this phase, the developers,
customers, test engineers, and stakeholders team up to
plan the testing process schedules, regular meetings,
and deliverables.
3. Release Readiness: This is the third phase in the agile
testing lifecycle where the test engineers review the
features which have been created entirely and test if the
features are ready to go live or not and the features that
need to be sent again to the previous development
phase.
4. Daily Scrums: This phase involves the daily morning
meetings to check on testing and determine the
objectives for the day. The goals are set daily to enable
test engineers to understand the status of testing.
5. Test Agility Review: This is the last phase of the agile
testing lifecycle that includes weekly meetings with the
stakeholders to evaluate and assess the progress against
the goals.

Benefits of Agile Testing

Below are some of the benefits of agile testing:
 Saves time: Implementing agile testing helps to make
cost estimates more transparent and thus helps to save
time and money.
 Reduces documentation: It requires less
documentation to execute agile testing.
  Enhances software productivity: Agile testing helps
to reduce errors, improve product quality, and enhance
software productivity.
 Higher efficiency: In agile software testing the work is
divided into small parts thus developer can focus more
easily and complete one part first and then move on to
the next part. This approach helps to identify minor
inconsistencies and higher efficiency.
 Improve product quality: In agile testing, regular
feedback is obtained from the user and other
stakeholders, which helps to enhance the software
product quality.
Limitations of Agile Testing
Below are some of the limitations of agile software testing:
 Project failure: In agile testing, if one or more members
leave the job then there are chances for the project
failure.
 Limited documentation: In agile testing, there is no or
less documentation which makes it difficult to predict the
expected results as there are explicit conditions and
requirements.
 Introduce new bugs: In agile software testing, bug
fixes, modifications, and releases happen repeatedly
which may sometimes result in the introduction of new
bugs in the system.
 Poor planning: In agile testing, the team is not exactly
aware of the end result from day one, so it becomes
challenging to predict factors like cost, time, and
resources required at the beginning of the project.
Pigs and chickens agile development yaani scrum meetings mein istemal hone wali ek slang term hai.
Yeh term ek kahani se nikli hai: Ek din, murgi apne dost suar ko suggest karti hai ki unhe ek
restaurant kholna chahiye. Suar maan jata hai aur poochhta hai ki restaurant ka naam kya hona
chahiye. Murgi kehti hai Ham aur Eggs. Suar mana kar deta hai, kyunki usko lagta hai ki restaurant
kholna uske liye zyada badi commitment hogi; usko slaughter hona padega jabki murgi ko sirf ande
dene padenge.

Pig aur chicken ki kahani daily scrum meetings mein aane wale logon ke tarikon ko define
karti hai.
Pigs woh log hote hain jo chopping block par hote hain - yeh committed log hote hain jinka
project mein stake hota hai aur jo project ke success ya failure ke liye zaroori hote hain.

Chickens woh log hote hain jo meeting attend karte hain lekin unka update, meeting progress
ya project se koi seedha sambandh nahi hota. Isliye, chickens woh log hote hain jo kuch
kehna chahte hain lekin aksar kuch contribute nahi karte. Meeting ke listeners maane jane

wale chickens aksar kisi bhi meeting ke

50 se 80 pratishat attendees hote hain.

Kanban in software engineering is a visual workflow management method used to efficiently

manage tasks and processes. Originally derived from the manufacturing industry, it has
become quite popular in software development. Here are some key aspects and features of
Kanban:

1. Visualize Workflow: A Kanban board is created with columns representing different

stages, such as "To Do," "In Progress," and "Done." Each task is displayed as a card,
which moves through the columns as the task progresses.
2. Limit Work in Progress (WIP): There are limits on how many tasks can be in each
stage at any given time. This ensures the team only works on as much as they can
handle, avoiding bottlenecks and overloading.
3. Manage Flow: The goal of Kanban is to maintain a smooth and uninterrupted
workflow. Tracking the movement of tasks helps identify and address inefficiencies
and delays.
4. Make Process Policies Explicit: Process policies are clearly defined and visible on
the Kanban board, so everyone knows what to expect and how to complete their work.
 5. Implement Feedback Loops: Regular reviews and feedback sessions are held to
ensure continuous improvement.
6. Improve Collaboratively, Evolve Experimentally: Kanban encourages team
collaboration and continuous improvement. Processes evolve and improve through
experimentation and iterative changes.

Kanban is part of agile methodologies, focusing on flexibility and continuous delivery. The
main benefit of Kanban is that it helps teams manage their workflow effectively, identify
bottlenecks, and improve overall productivity.

Extreme Programming (XP) is a software development methodology that emphasizes

customer satisfaction, teamwork, and frequent delivery of functional software. It is one of the
most well-known agile methodologies and is designed to improve software quality and
responsiveness to changing customer requirements. Here are the key aspects and practices of
Extreme Programming in detail:

Core Values

1. Communication: Emphasizes direct communication within the team and with customers to
ensure everyone is on the same page.
2. Simplicity: Focuses on developing only what is needed, avoiding over-engineering and
complexity.
3. Feedback: Regular feedback from the system, the customer, and the team helps improve the
development process.
4. Courage: Encourages taking bold steps and making necessary changes even if they are
difficult.
5. Respect: Fosters mutual respect among team members, creating a positive and collaborative
working environment.
Key Practices

1. Test-Driven Development (TDD): Writing tests before writing the actual code. This ensures
that the code works as expected and facilitates refactoring.
2. Pair Programming: Two programmers work together at one workstation. One writes the
code (the driver) while the other reviews each line of code as it’s written (the observer or
navigator).
3. Continuous Integration: Code changes are integrated into the main codebase frequently,
often multiple times a day, to avoid integration problems.
4. Refactoring: Continuously improving the design of the code without changing its
functionality, making the code simpler and more maintainable.
5. Small Releases: Delivering small, functional pieces of the software frequently. This allows for
quicker feedback and reduces the risk of large, unmanageable changes.
6. Collective Code Ownership: Every team member is responsible for the entire codebase.
Anyone can make changes anywhere in the code at any time.
7. Coding Standards: Adhering to a set of agreed-upon coding standards to ensure code
consistency and readability.
8. Sustainable Pace: Working at a pace that can be sustained indefinitely without causing
burnout. Typically, this means not working overtime regularly.
9. Customer Involvement: The customer (or a customer representative) is always available to
provide feedback, clarify requirements, and set priorities.
10. Planning Game: A collaborative planning process where the team and the customer decide
the features to be implemented in the next iteration based on their priority and the team's
capacity.

Life Cycle of Extreme Programming (XP)

The Extreme Programming Life Cycle consist of five phases:

Life Cycle of Extreme Programming (XP)

1. Planning: The first stage of Extreme Programming is

planning. During this phase, clients define their needs in
concise descriptions known as user stories. The team
 calculates the effort required for each story and
schedules releases according to priority and effort.
2. Design: The team creates only the essential design
needed for current user stories, using a common analogy
or story to help everyone understand the overall system
architecture and keep the design straightforward and
clear.
3. Coding: Extreme Programming (XP) promotes pair
programming i.e. wo developers work together at one
workstation, enhancing code quality and knowledge
sharing. They write tests before coding to ensure
functionality from the start (TDD), and frequently
integrate their code into a shared repository with
automated tests to catch issues early.
4. Testing: Extreme Programming (XP) gives more
importance to testing that consist of both unit tests and
acceptance test. Unit tests, which are automated, check
if specific features work correctly. Acceptance tests,
conducted by customers, ensure that the overall system
meets initial requirements. This continuous testing
ensures the software’s quality and alignment with
customer needs.
5. Listening: In the listening phase regular feedback from
customers to ensure the product meets their needs and
to adapt to any changes.
Advantages of XP

 Improved Software Quality: Practices like TDD and refactoring lead to higher quality and
more maintainable code.
 Flexibility: The iterative approach allows for easy accommodation of changing requirements.
 Customer Satisfaction: Frequent releases and customer involvement ensure that the
product meets user needs.
 Enhanced Team Collaboration: Practices like pair programming and collective code
ownership foster teamwork and knowledge sharing.

Challenges of XP

 Cultural Shift: Requires significant changes in mindset and practices, which can be
challenging for teams accustomed to traditional development methods.
 Discipline: Requires strict adherence to practices, which can be difficult to maintain.
 Resource Intensive: Practices like pair programming can be seen as resource-intensive,
although they can lead to higher quality and fewer bugs in the long run.

Extreme Programming aims to improve software development by focusing on customer

needs, fostering collaboration, and promoting high-quality, maintainable code. Its practices
and values are designed to create a productive and positive development environment that
can quickly adapt to changing requirements.
The Dynamic Systems Development technique (DSDM) is
an associate degree agile code development approach that
provides a framework for building and maintaining systems. The
DSDM philosophy is borrowed from a modified version of the
sociologist principle—80 % of An application is often delivered in
twenty percent of the time it’d desire deliver the entire (100
percent) application.
DSDM is An iterative code method within which every iteration
follows the 80% rule that simply enough work is needed for
every increment to facilitate movement to the following
increment. The remaining detail is often completed later once a
lot of business necessities are noted or changes are requested
and accommodated.
Principles of DSDM

DSDM is built on eight core principles that ensure project success:

1. Focus on the Business Need: Every decision is taken with business priorities in mind to
deliver the maximum business value.
2. Deliver on Time: Using timeboxing, projects are kept on schedule with set deadlines for each
phase.
3. Collaborate: Effective collaboration between all stakeholders, including the development
team and business users, is emphasized.
4. Never Compromise Quality: Quality is never sacrificed; standards are set from the start and
maintained throughout.
5. Build Incrementally from Firm Foundations: Development progresses in iterations, building
on a solid understanding of requirements and architecture.
6. Develop Iteratively: Iterative development allows for refinement and adaptation based on
feedback.
7. Communicate Continuously and Clearly: Open and clear communication is crucial for
effective collaboration and progress tracking.
8. Demonstrate Control: Project control is maintained through clear and frequent status
checks and adjustments.

DSDM Life Cycle

1. Feasibility Study

 Objective: Check if the project is possible and worth doing. Understand the basic business
requirements and constraints.
 Output: Feasibility Report, Outline Plan, Risk Log

2. Business Study

 Objective: Understand the detailed business needs and information requirements for the
project. Identify the basic design and maintainability requirements.
 Output: Business Study Report, Prioritized Requirements List, Outline Prototype
3. Functional Model Iteration

 Objective: Create small models (prototypes) that show how the system will work. Gather
additional requirements by getting feedback from users as they try out the prototypes.
 Output: Functional Prototypes, Updated Prioritized Requirements List

4. Design and Build Iteration

 Objective: Improve the prototypes created during the functional model iteration to make
sure they provide real business value to end users. Sometimes, functional model iteration
and design and build iteration happen at the same time.
 Output: Tested System Components, User Documentation

5. Implementation

 Objective: Deploy the latest version of the code (an operational prototype) into the real
environment. Note that:
o (a) The increment might not be 100% complete, or
o (b) Changes may be requested when the increment is deployed. In either case,
DSDM development continues by returning to the functional model iteration
activity.
 Output: Implemented System, Project Review Report

Below diagram describe the DSDM life cycle:

FDD stands for Feature-Driven Development. It is an agile

iterative and incremental model that focuses on progressing the
features of the developing software. The main motive of feature-
driven development is to provide timely updated and working
software to the client. In FDD, reporting and progress tracking is
necessary at all levels.

History
FDD was first applied in the year 1997 on a real-world application
by Jeff De Luca for large software development with specific
needs of 15-month and 50 persons and published as a discussion
in book Java Modeling in Color with UML in the year 1999.
FDD Lifecycle
 Build overall model
 Build feature list
 Plan by feature
 Design by feature
 Build by feature

Characteristics of FDD
 Short iterative: FDD lifecycle works in simple and short
iterations to efficiently finish the work on time and gives
good pace for large projects.
 Customer focused: This agile practice is totally based
on inspection of each feature by client and then pushed
to main build code.
 Structured and feature focused: Initial activities in
lifecycle builds the domain model and features list in the
beginning of timeline and more than 70% of efforts are
given to last 2 activities.
 Frequent releases: Feature-driven development
provides continuous releases of features in the software
and retaining continuous success of the project.
Advantages of FDD
 Reporting at all levels leads to easier progress tracking.
 FDD provides continuous success for larger size of teams
and projects.
 Reduction in risks is observed as whole model and design
is build in smaller segments.
 FDD provides greater accuracy in cost estimation of the
project due to feature segmentation.
Disadvantages of FDD
 This agile practice is not good for smaller projects.
 There is high dependency on lead programmers,
designers and mentors.
 There is lack of documentation which can create an issue
afterwards.