UNIT-1

Software development life cycle (SDLC) is a structured process that is used to design,
develop, and test good-quality software. SDLC, or software development life cycle, is a
methodology that defines the entire procedure of software development step-by-step.

1. The Goal of the SDLC life cycle model is to deliver high-quality, maintainable
software that meets the user’s requirements.
2. SDLC in software engineering models outlines the plan for each stage so that each
stage of the software development model can perform its task efficiently to deliver
the software at a low cost within a given time frame that meets users’ requirements.
3. SDLC is a process followed for software building within a software organization.
4. SDLC consists of a precise plan that describes how to develop, maintain, replace, and
enhance specific software.
5. The life cycle defines a method for improving the quality of software and the all-
around development process.

Stages of the Software Development Life Cycle

1. SDLC specifies the task(s) to be performed at various stages by a software engineer

or developer. It ensures that the end product is able to meet the customer’s
expectations and fits within the overall budget.
2. Hence, it’s vital for a software developer to have prior knowledge of this software
development process. SDLC is a collection of these six stages, and the stages of SDLC
are as follows:
The SDLC Model involves six phases or stages while developing any software.
Stage-1: Planning and Requirement Analysis
Planning is a crucial step in everything, just as in software development. In this same
Stage, Requirement analysis is also performed by the developers of the organization. This is
attained from customer inputs, and sales department/market surveys.
The information from this analysis forms the building blocks of a basic project. The quality
of the project is a result of planning. Thus, in this stage, the basic project is designed with
all the available information.
Stage-2: Defining Requirements
In this stage, all the requirements for the target software are specified. These requirements
get approval from customers, market analysts, and stakeholders.
This is fulfilled by utilizing SRS (Software Requirement Specification). This is a sort of
document that specifies all those things that need to be defined and created during the
entire project cycle.
Stage-3: Designing Architecture
SRS is a reference for software designers to come up with the best architecture for the
software. Hence, with the requirements defined in SRS, multiple designs for the product
architecture are present in the Design Document Specification (DDS).
This DDS is assessed by market analysts and stakeholders. After evaluating all the possible
factors, the most practical and logical design is chosen for development.
Stage 3: Design

Stage-4: Developing Product

At this stage, the fundamental development of the product starts. For this, developers use
a specific programming code as per the design in the DDS. Hence, it is important for the
coders to follow the protocols set by the association. Conventional programming tools like
compilers, interpreters, debuggers, etc. are also put into use at this stage. Some popular
languages like C/C++, Python, Java, etc. are put into use as per the software regulations.
Stage 4: Development

Stage-5: Product Testing and Integration

After the development of the product, testing of the software is necessary to ensure its
smooth execution. Although, minimal testing is conducted at every stage of
SDLC. Therefore, at this stage, all the probable flaws are tracked, fixed, and retested. This
ensures that the product confronts the quality requirements of SRS.
Documentation, Training, and Support:
Software documentation is an essential part of the software development life cycle. A well-
written document acts as a tool and means to information repository necessary to know
about software processes, functions, and maintenance. Documentation also provides
information about how to use the product. Training in an attempt to improve the current
or future employee performance by increasing an employee’s ability to work through
learning, usually by changing his attitude and developing his skills and understanding.
Stage 5: Testing

Stage-6: Deployment and Maintenance of Products

After detailed testing, the conclusive product is released in phases as per the organization’s
strategy. Then it is tested in a real industrial environment. It is important to ensure its
smooth performance. If it performs well, the organization sends out the product as a whole.
After retrieving beneficial feedback, the company releases it as it is or with auxiliary
improvements to make it further helpful for the customers. However, this alone is not
enough. Therefore, along with the deployment, the product’s supervision.
Stage 6: Deployment and Maintenance

What is Software Testing?

1. Within the software development life cycle, software testing is a very critical phase,
focusing on the functionality, reliability, and performance of a software application
in meeting the specified requirements. It is an execution of the application under
controlled conditions to trace existing software bugs or defects, if any.
2. The main aim for doing software testing is to find errors, gaps, or missing
requirements in contrast with the actual requirements.
3. Software testing includes different types of functional testing to evaluate specific
functions or features of the application; integration testing evaluates how the
interactions take place among the various components of the software; and system
 testing includes the assessment of performance made on the application in an
environment resembling production.

It helps to ensure that the new changes are not affecting the existing functionality of the
software in an adverse way. Software testing can be performed manually or with the
assistance of automated tools. The basic premise of manual testing means human testers
enacting as end-users to conduct tests and report issues, while in an automated form,
predefined testing cases get executed with the help of specialized tools.

Key Objectives of Software Testing

Software testing is a very paramount activity within the software development

lifecycle, whereby its aim is to provide product realization that is both reliable and
effective, thus of high quality.

Here are five main objectives of software testing:

1. Verification and Validation: It is a verification activity carried out to assure that the product
is developed in a way that requires the same time validating if it is fit for the intended use
and expectations of the stakeholders. Follow this with the assurance of expected behaviour
in the software and to give confidence in quality, thus meeting the intended purpose.
2. Identification of Defects: The other basic aim of software testing in the very first stage is to
detect as many defects, bugs, and errors in the software as possible. If found at this stage, it
is way less costly and doesn’t take long to fix, so the positive impact on quality and stability
is out of the question.
3. Defects Prevention: In very simple words, the purpose of software testing whether it
is mobile application testing or web application testing is not a defect find; rather, it is more
for preventing defects. Systematic software testing and result analysis let the development
team identify the causes of defects and possible corrective actions, so as not to repeat its
occurrence in the future, ensuring a better quality standard in practice of software
development.
4. Ensuring Quality Attributes in the Product: Some of the quality attributes tested with
software testing include functionality, performance, usability, security, compatibility, and
 scalability, among others. It means the testing processes ensure that the software product is
attuned to quality standards that have been defined either by the development team or the
standards defined within the industry for smooth user experience.
5. Risk Management: Software testing like automation testing or manual testing, largely helps
in managing the risks linked to software failures. Testing identifies all probable problems
that will have an impact on the users and consequently the operation of the business in bad
ways, and it allows time for fixing; hence, it reduces the opportunity risks associated with
deployment. This includes assessing security vulnerabilities, performance bottlenecks, and
reliability problems in software in such a way that these areas of the software will not
expose the product to significant risks on software release.

Do you find your software should meet the above needs to bug free and have a great user
experience? Contact us today for software testing for your app.

5 Goals of Software Testing

The main goals of software testing are designed to ensure the delivery of a high-quality
software product that meets the needs of its users and stakeholders. Here are five
important goals of software testing:

1. Ensure Software Quality: A fundamental goal of software testing is to ensure that the
software meets the required quality standards and specifications. The quality involves the
different characteristics or attributes, such as functionality, reliability, usability, efficiency,
maintainability, and portability. Testing is done to prove these attributes of the software
against a specified set of conditions in which they would be the software to perform
properly.
2. Detection and identification of defects: the key objective is to make sure that detection and
identification of defects, bugs, and errors of software are done in an early and effective
manner.
3. Reduced Development Costs: In software development, most of the cost of rectifying
software defects is in the identification of the software defects, and the earlier this is done,
the cheaper it is. The cost of fixing a defect increases significantly with the time it has been
 detected, especially after deployment. Software testing helps minimize those costs by
identifying the problem and dealing with it at an early stage.
4. Verify Compliance with Requirements: Software testing verifies that the software meets all
specified requirements and complies with industry standards, legal regulations, and user
expectations. This includes both functional requirements (what the software does) and non-
functional requirements (how the software performs under certain conditions).
5. Facilitate User Acceptance: A third major goal of software testing, which is as important as
the rest, is facilitating user acceptance. This includes subjecting software to various user-
based tests to ensure it is intuitive, user-friendly, and capable of efficiently carrying out the
desired tasks. This is actually a critical focus area of user acceptance testing (UAT) by the
team to ensure that the software will, at the end of the day, meet the desires and
expectations of the users.

These objectives reiterate that software testing is not just an activity of a development
phase but a continuous practice, helping in making efficient delivery with high quality,
maximizing user satisfaction, and lowering risks associated with deployment and software
use.

Benefits of Software Testing

Software testing is amongst the most essential parts of the software development process,
as it brings a large number of benefits altogether and helps one to build reliable, high-
quality products that are easy to use.

These include the five key benefits of software testing:

1. Product Quality Improvement: One of the greatest advantages that accrues from software
testing is the improvement of product quality related to the software application. It is
through this testing that bugs are derived and corrected at earlier stages of development,
meaning software will perfectly run under any environment. This would also ensure the
software adheres to stipulated requirements of functionality, performance, and usability
standards that accrue to a more polished and improved product.
2. Enhances User Satisfaction: Software testing is crucial in creating a positive user experience.
In so doing, testing ensures that from the use of the software, the user is comfortably able
to perform the said tasks. That is, the software should be intuitive, easy to use, and with no
critical bugs that are likely to frustrate the users. This way, satisfied users are much more
likely to become loyal customers who recommend the product to others and comment
positively, which eventually helps in the success of this product.
3. Lowers Cost and Time of Development: The cost of fixing any defect found in the later
stages of development or after deployment is many times what could have been invested in
fixing it when identified. The early integration of software testing into the development
lifecycle is a key step in finding and fixing issues as they emerge. It really saves from the
economy of time and resources: avoiding either wastage or reduction of the whole
development cost that could result from expensive patches and updates after releasing.
4. Helps in Standard Compliance: Most industries require software that complies with a
certain standard and regulation, especially those referring to security, privacy, and
accessibility. In this connection, testing shall ensure that the product complies with
standards. This avoids the implications of legal actions and fines and loss of reputation.
Compliance is therefore key in the fostering of trust by the users and stakeholders, more so
in sensitive sectors like finance, health, and government.
5. Risk Mitigation: Software testing provides an option for the identification and mitigation of
potential risk, which will be increased through operations via software. These include not
only technical risks, such as security vulnerabilities and performance problems but also
business ones, like the impossibility of serving the market or losing the reputation of the
company. Then, with such risks in mind, it will be possible for the organization to take
proactive steps in avoiding these risks before software is released, thus ensuring a smoother
launch and operation through testing.

Testing Objectives in Different Testing Phases

Testing is a critical phase in software development that ensures the quality, reliability, and
performance of software before it reaches end-users. Each testing phase has its own
objectives, tailored to validate different aspects of the software. These phases include unit
testing, integration testing, system testing, and acceptance testing.
1. Unit Testing: In Unit Testing, the smallest parts of the application are the main focus, such
as modules or functions. The objective here is to ensure each isolated unit is working
properly and effectively. It is an aspect usually in the job description of a developer, to
detect bugs while they are still at a primitive stage, making the debugging of the code
relatively easy and improving the quality of the code.
2. Integration testing: Integration testing comes after unit testing, whereby the main focus
moves toward how different units come together. In this case, major intentions will be on
locating problems with the interface between integrated components. This is the critical
stage when some faults that could not be indicated during unit testing—of a nature like data
format mismatches, or poor interface interactions—are being exposed.
3. System Testing: System Testing is conducted on a complete, integrated system to evaluate
the system’s compliance with its requirements. This is an examination that is supposed to
prove, above all, the ability of the system to meet all the stated requirements and, at the
same time, demonstrate, or rather prove, that the system can operate in an environment
that is meant to mimic production. System testing includes types of testing such as
performance testing, security testing, usability testing, and others. Very often, the
Acceptance Testing is the last phase aimed to test the readiness of the system for
deployment and use from end-users. Its objective is to confirm that the software satisfies
the business needs and requirements outlined by the user.
4. Acceptance testing: Acceptance testing can further be broken down into User Acceptance
Testing (UAT) when real users are testing the system. Beta Testing is the one where a
version is released to a limited audience to get some testing and feedback. Each successive
test phase builds on the previous one, accelerating the level of software readiness for
deployment and ensuring that all constituent parts or pieces of the application are up to
quality and user expectations.

Software Testing Limitation

1: Incomplete Test Coverage
Definition: Test coverage refers to the extent to which the codebase is exercised by a set of
tests.
Example: Consider a financial software application that handles millions of transactions
daily. Testing every possible combination of inputs and scenarios is practically impossible.
Therefore, some code paths may remain untested.

Statistics: According to a study by Capers Jones, in typical software projects, test coverage
rarely exceeds 35% to 40%. [Source: “Applied Software Measurement” by Capers Jones]

Software Testing Limitation

2: Time and Resource Constraints
Definition: Limited time and resources can constrain the number and depth of tests that can
be conducted.

Example: A startup developing a mobile app may have a tight release schedule and a small
testing team. As a result, they may not be able to conduct extensive testing, leaving room
for undiscovered defects.

Statistics: In a survey by the World Quality Report, 39% of respondents cited insufficient
time and resources as a significant challenge in software testing. [Source: World Quality
Report 2020-21]

Software Testing Limitation

3: Assumption of Correct Requirements
Definition: Software testing is based on the assumption that the requirements provided are
correct and complete.

Example: If the requirements for a healthcare software system specify that patient records
should be accessible only to authorized personnel, but the requirements are incorrect or
incomplete, no amount of testing can catch this issue.

Statistics: In the Standish Group’s Chaos Report, incomplete or unclear requirements were
cited as a primary cause of project failure in 13.1% of cases. [Source: Standish Group’s Chaos
Report]

Software Testing Limitation

4: Automation Challenges
Definition: While test automation can improve efficiency, not all tests can be easily
automated.
Example: User interface changes in a web application can break automated tests that rely
on specific element locators. Continuous maintenance of these tests can become a
resource-intensive task.

Statistics: According to Statista, only 32% of organizations have automated more than 50%
of their test cases. [Source: Statista’s IT Industry Outlook 2021]

Software Testing Limitation

5: Bias and Assumptions
Definition: Testers may unknowingly introduce bias or make assumptions about how users
will interact with software.

Example: Testers familiar with the software’s intended functionality may unconsciously
overlook unconventional user behaviors or unexpected inputs.

Statistics: A study published in the “Journal of Systems and Software” found that human
bias influenced test design in 58% of the cases studied. [Source: “Impact of Human Bias on
Software Testing” by M. Felderer et al.]

Software Testing Limitation

6: Testing in Isolation
Definition: Testing often occurs in isolated environments that may not replicate the
complexity of real-world usage.

Example: A software application tested in a controlled test environment may perform

flawlessly, but in the unpredictable real world, it may fail due to factors like network latency
or unexpected user actions.

Statistics: A report by Tricentis stated that 40% of defects reported by users were related to
performance issues that didn’t manifest in test environments. [Source: Tricentis’ “Software
Fail Watch 2021”]

Software Testing Limitation

7: The Pesticide Paradox
Definition: The pesticide paradox states that if the same tests are repeated over and over,
they may become ineffective in finding new defects.

Example: Running the same set of tests for multiple releases without updating them can
result in missing defects that arise from new code changes.
Statistics: The National Institute of Standards and Technology (NIST) recommends regularly
reviewing and updating test cases to avoid the pesticide paradox.

Software Testing Limitation

8: Limited Domain Knowledge

Definition: Testers may lack domain-specific knowledge, which can hinder their ability to
design relevant test cases.

Example: Testing a complex financial software system without a deep understanding of

financial regulations and practices can lead to the oversight of critical compliance-related
defects.

Statistics: In a survey conducted by TechWell, 24% of respondents cited a lack of domain

expertise as a challenge in their testing efforts. [Source: TechWell’s “State of Software
Testing 2021”]

Software Testing Limitation

9: False Sense of Security
Definition: Successful tests may provide a false sense of security, assuming that no further
issues exist.

Example: A web application passes all functional tests, but its security vulnerabilities go
unnoticed. This can lead to data breaches and security incidents.

Statistics: The “Verizon Data Breach Investigations Report” found that 85% of data breaches
involved the exploitation of known vulnerabilities. [Source: Verizon’s Data Breach
Investigations Report 2021]

Software Testing Limitation

10: Human Error
Definition: Software testing involves human testers who are susceptible to errors.

Example: Testers may misinterpret requirements, incorrectly configure test environments,

or make data entry mistakes, leading to inaccurate test results.
Difference between Bug, Defect, Error, Fault & Failure
1. In this section, we are going to discuss the difference between the Bug, Defect, Error, Fault & Failure as we
understood that all the terms are used whenever the system or an application act abnormally.
2. Sometimes we call it an error and sometimes a bug or a defect and so on. In software testing, many of the new test
engineers have confusion in using these terminologies.
3. Generally, we used these terms in the Software Development Life Cycle (SDLC) based on the phases. But there is a
conflict in the usage of these terms.
4. In other words, we can say that in the era of software testing, the terms bugs, defects, error, fault, and failure come
across every second of the day.
5. But for a beginner or the inexperienced in this field, all these terminologies may seem synonyms. It became essential
to understand each of these terms independently if the software doesn't work as expected.

What is a bug?
In software testing, a bug is the informal name of defects, which means that software or application is not working as per
the requirement. When we have some coding error, it leads a program to its breakdown, which is known as a bug. The test
engineers use the terminology Bug.

If a QA (Quality Analyst) detect a bug, they can reproduce the bug and record it with the help of the bug report template.

What is a Defect?
When the application is not working as per the requirement is knows as defects. It is specified as the aberration from
the actual and expected result of the application or software.

In other words, we can say that the bug announced by the programmer and inside the code is called a Defect.

What is Error?
The Problem in code leads to errors, which means that a mistake can occur due to the developer's coding error as the
developer misunderstood the requirement or the requirement was not defined correctly. The developers use the
term error.
What is Fault?
The fault may occur in software because it has not added the code for fault tolerance, making an application act up.

A fault may happen in a program because of the following reasons:

o Lack of resources
o An invalid step
o Inappropriate data definition

What is Failure?
1. Many defects lead to the software's failure, which means that a loss specifies a fatal issue in software/ application
or in its module, which makes the system unresponsive or broken.
2. In other words, we can say that if an end-user detects an issue in the product, then that particular issue is called
a failure.
3. Possibilities are there one defect that might lead to one failure or several failures.
4. For example, in a bank application if the Amount Transfer module is not working for end-users when the end-user
tries to transfer money, submit button is not working. Hence, this is a failure.
5. The flow of the above terminologies are shown in the following image:
Bug Vs. Defect Vs. Error Vs. Fault Vs. Failure
We have listed some of the vital differences between bug, defect, error, fault, and failure in the below table.

Comparison Bug Defect Error Fault Failure

basis

An Error is a
The Defect is the The Fault is a state
mistake made in If the software has
It is an informal difference between that causes the
the code; that's lots of defects, it
Definition name specified to the actual software to fail to
why we cannot leads to failure or
the defect. outcomes and accomplish its
execute or causes failure.
expected outputs. essential function.
compile code.

The Testers identify

The Developers The failure finds
the defect. And it
The Test and automation Human by the manual test
was also solved by
Raised by Engineers submit test mistakes cause engineer through
the developer in
the bug. engineers raise fault. the development
the development
the error. cycle.
phase or stage.

Different type of Different type of

bugs are as Defects are as Different type of Different type of
Different follows: follows: Error is as below: Fault are as follows:
types -----
Based on priority:
o Logic bugs o Syntactic o Business
o Algorithmic o High Error Logic Faults
bugs o Medium
 o Resource o Low o User o Functional
bugs And based on the interface and Logical
error Faults
severity:
o Flow o Faulty GUI
control o Performance
o Critical
error Faults
o Major
o Error o Security
o Minor
handling Faults
o Trivial
error o Software/
o Calculation hardware
error fault
o Hardware
error
o Testing
Error

The reasons for

having
an error are as
follows:
Errors in the code.
The below reason The Mistake of The reasons behind
leads to some values. the fault are as
the defects: If a developer is follows:
Giving incorrect unable to compile A Fault may occur
and wrong inputs. or run a program by an improper step Following are
Following are Dilemmas and successfully. in the initial stage, some of the most
reasons which errors in the Confusions and process, or data important reasons
may cause outside behavior issues in definition. behind the failure:
Reasons
the bugs: and inside programming. Inconsistency or Environmental
behind
Missing coding structure and Invalid login, loop, issue in the condition
Wrong coding design. and syntax. program. System usage
Extra coding An error in coding Inconsistency An irregularity or Users
or logic affects the between actual loophole in the Human error
software and and expected software that leads
causes it to outcomes. the software to
breakdown or the Blunders in design perform
failure. or requirement improperly.
actions.
Misperception in
understanding the
requirements of
the application.
 With the help of
Following are the the following, we Below are ways to The fault can be
The way to
way to stop can prevent prevent prevented with the
prevent failure are
the bugs: the Defects: the Errors: help of the
as follows:
Test-driven Implementing Enhance the following:
Confirm re-
development. several innovative software quality Peer review.
testing.
Offer programming with system Assess the
Review the
Way to programming methods. review and functional
requirements and
prevent language support. Use of primary and programming. necessities of the
revisit the
the Adjusting, correct software Detect the issues software.
specifications.
reasons advanced, and development and prepare a Execute the
Implement
operative techniques. suitable detailed code
current protective
development Peer review mitigation plan. analysis.
techniques.
procedures. It is executing Validate the fixes Verify the
Categorize and
Evaluating the consistent code and verify their correctness of
evaluate errors
code reviews to evaluate quality and software design and
and issues.
systematically. its quality and precision. programming.
correctness.

Software Testing Life Cycle (STLC)

STLC stands for Software Testing Life Cycle. STLC is a sequence of different activities
performed by the testing team to ensure the quality of the software or the product.

 STLC is an integral part of Software Development Life Cycle (SDLC). But, STLC deals
only with the testing phases.
 STLC starts as soon as requirements are defined or SRD (Software Requirement
Document) is shared by stakeholders.
 STLC provides a step-by-step process to ensure quality software.
 In the early stage of STLC, while the software or the product is developing, the tester
can analyze and define the scope of testing, entry and exit criteria and also the Test
Cases. It helps to reduce the test cycle time along with better quality.
 As soon as the development phase is over, the testers are ready with test cases and
start with execution. This helps to find bugs in the initial phase.

STLC Phases
STLC has the following different phases but it is not mandatory to follow all phases. Phases
are dependent on the nature of the software or the product, time and resources allocated
for the testing and the model of SDLC that is to be followed.
There are 6 major phases of STLC −
 Requirement Analysis − When the SRD is ready and shared with the stakeholders, the
testing team starts high level analysis concerning the AUT (Application under Test).
 Test Planning − Test Team plans the strategy and approach.
 Test Case Designing − Develop the test cases based on scope and criteria’s.
 Test Environment Setup − When integrated environment is ready to validate the
product.
 Test Execution − Real-time validation of product and finding bugs.
 Test Closure − Once testing is completed, matrix, reports, results are documented.

In this chapter, we will understand the factors of comparison between STLC and SDLC. Let us
consider the following points and thereby, compare STLC and SDLC.

 STLC is part of SDLC. It can be said that STLC is a subset of the SDLC set.
 STLC is limited to the testing phase where quality of software or product ensures. SDLC
has vast and vital role in complete development of a software or product.
 However, STLC is a very important phase of SDLC and the final product or the software
cannot be released without passing through the STLC process.
 STLC is also a part of the post-release/ update cycle, the maintenance phase of SDLC
where known defects get fixed or a new functionality is added to the software.

The following table lists down the factors of comparison between

SDLC and STLC based on their phases −

Phase SDLC STLC

 Business Analyst gathers  Testing team reviews and

requirements. analyzes the SRD
 Development team document.
analyzes the requirements.  Identifies the testing
Requirement
 After high level, the requirements - Scope,
Gathering
development team starts Verification and Validation
analyzing from the key points.
architecture and the design  Reviews the requirements
perspective. for logical and functional
 relationship among various
modules. This helps in the
identification of gaps at an
early stage.

 The architecture of SDLC

helps you develop a high-
 In STLC, either the Test
level and low-level design of
Architect or a Test Lead
the software based on the
usually plan the test
requirements.
Design strategy.
 Business Analyst works on
 Identifies the testing points.
the mocker of UI design.
 Resource allocation and
 Once the design is
timelines are finalized here.
completed, it is signed off
by the stakeholders.

 Testing team writes the test

scenarios to validate the
 Development team starts quality of the product.
developing the software.  Detailed test cases are
 Integrate with different written for all modules
Development systems. along with expected
 Once all integration is done, behaviour.
a ready to test software or  The prerequisites and the
product is provided. entry and exit criteria of a
test module are identified
here.

 The Test team confirms the

environment set up based
 Development team sets up
on the prerequisites.
Environment a test environment with
 Performs smoke testing to
Set up developed product to
make sure the environment
validate.
is stable for the product to
be tested.

 The actual testing is carried

 System Integration testing
out in this phase. It includes
starts based on the test
unit testing, integration
cases.
testing, system testing,
 Defects reported, if any, get
defect retesting, regression
Testing retested and fixed.
testing, etc.
 Regression testing is
 The Development team
performed here and the
fixes the bug reported, if
product is signed off once it
any and sends it back to the
meets the exit criteria.
tester for retesting.
  UAT testing performs here
after getting sign off from
SIT testing.

 Smoke and sanity testing in

production environment is
 Once sign-off is received
completed here as soon as
Deployment/ from various testing team,
product is deployed.
Product application is deployed in
 Test reports and matrix
Release prod environment for real
preparation are done by
end users.
testing team to analyze the
product.

 In this phase, the

 It covers the post maintaining of test cases,
deployment supports, regression suits and
Maintenance
enhancement and updates, automation scripts take
if any. place based on the
enhancement and updates.

The Role of Software Testing in the Software Development

Process
Software testing is a bedrock in the software development life cycle process; it plays a
crucial role in ensuring that an end product has no bugs and remains of high quality. This is a
complete process that aims not just to find and fix defects but also involves considering the
software’s usability from an end-user’s viewpoint.

Bug Prevention and Quality Enhancement

Software testing is essentially a mechanism for averting the consequences of overlooked
functionalities. Finding out missing features or coding mistakes while also saving efforts of
starting the difficult task again from the first requirement analysis. This preventive measure
is crucial in preventing potential disasters that may have arisen due to gathering the wrong
requirements or errors in coding styles, saving time and resources.

Usability Evaluation
Software testing is more than just finding bugs; it carefully tests how easy usability would be
from a user’s point of view. This means that the final product should be what users expect,
with comfort and simplicity of interaction being highlighted. By considering these usability
aspects during testing, developers can achieve the best match between software and user
needs and preferences.

Verification of Software
Verification and validation are a significant part of software testing as they involve
scrutinizing every aspect documented in the Software Requirements Specifications (SRS)
document. This strict analysis also includes the performance of software in unforeseen
situations, such as incorrect input data or changes to environmental conditions. Through
these scenarios, testing gives confidence that the system is capable of managing such
variations well enough to correct an error before it occurs.

Accelerating Development
Software testing plays an important role as an accelerant of development. Testers identify
bugs and describe scenarios that lead to bug reproduction, providing developers with
insights for efficient problem resolution. Parallel work by testers and developers makes it
possible to develop depth in the manner in which design is understood from an
implementing point of view. This also speeds up the development process because the
chances of bugs are reduced.

Software Testing Goals

As a dynamic and integral part of the Software Development Life Cycle (SDLC), software
testing works according to a multi-dimensional strategy that has purposes that can be
divided into immediate goals, long-term goals, and post-implementation goals. This holistic
approach intends to guarantee software quality, user satisfaction, and efficient risk
management at all stages of development.

Immediate Goals
1. Bug Discovery
This is the immediate objective of software testing, which lies at its core. It aims to reveal
and rectify mistakes in any phase of the software development process. The higher success
in software testing is strongly related to the early detection of a number of problems, where
developers could fix all flaws relatively quickly. This first phase establishes the basis for a
solid and dependable software product.

2. Bug Prevention
Bug prevention is the immediate action based on bug discovery. This is not merely about
correction; it signifies a learning process within the software development team. Analysis
and insights from identified issues contribute to common knowledge, thus preventing
identical bugs in subsequent phases or future projects. Bug prevention transforms into a
preventive activity, lowering the probability of bug recurrence.

Long-Term Goals
1. Quality Enhancement
Quality is one of the main long-term goals of the software product. It includes the
correctness, completeness, integrity, efficiency and consistency of the software product.
The process of testing becomes instrumental in ensuring a superior-quality product. Each
feature related to quality needs detailed processing. Software testing plays a crucial role in
reaching these standards. This results in a completely functional software product that can
even surpass user expectations.

2. Customer Satisfaction
Customer satisfaction is the ultimate measure of success from the user’s point of view.
Thorough and detailed testing becomes essential to ensuring that a software product is not
only satisfactory but also exceeds customers’ expectations. User needs must be perfectly
fitted into the user experience, user interface, and overall functionality. Therefore, software
testing is a vital component of constructing and sustaining favorable user connections.

3. Reliability
Reliability is about building confidence among users that the software will not fail. This
continuous goal is to win the trust of customers by providing quality products all along.
Reliability is not only about whether something works; it includes the predictable and stable
nature of the software in many diverse usage situations. A stable software product
contributes to long-lasting user relationships.

4. Risk Management
Recognizing the uncertainty associated with organizational events, risk management
becomes an essential aspect of avoiding potential losses and negative consequences.
Successful testing helps reduce the odds of product failure and improves risk management
across various situations. A proactive method of identifying and mitigating possible risks
throughout testing increases the overall resilience of the software product.

Post-Implemented Goals
1. Reduce Maintenance Cost
Tracking errors after release is more difficult and costly. An appropriate and comprehensive
testing process becomes crucial to minimize the chances of post-release failures. The testing
process also has serious financial problems after release; therefore, the tests must be
performed literally from scratch, and everything should work correctly.

2. Improved Software Testing Process

Post-implementation goals specify the polishing of testing processes for subsequent
projects. Bug history and post-implementation results can be assessed to identify any
shortcomings in the current testing procedure. This allows for more comprehensive testing
of future software initiatives. Lessons that are learned from previous projects become
priceless in designing a standby testing approach that is not only profitable but also flexible
enough to adapt to resulting changes within the software development horizon.

Software testing has several strategic goals that go beyond just detecting bugs and are
instead oriented toward long-term quality improvement. A holistic testing approach not
only prevents you from falling into immediate pre-assignment of money but also
contributes to the improvement of software development practices, which eventually leads
to the delivery of high-quality, reliable, and people-oriented products.

Seven Principles of Software Testing

In the complex world of software testing, there are seven guiding principles. These
principles take us into the subtleties of testing, reaffirming our appreciation for context-
dependency, highlighting the value of early testing, and reinforcing that there is no process
to guarantee perfection, but rather it signals defect. Let us discover these principles and
understand their importance in the world of software development.

1. Context-Dependency
It should be noted that testing is not one size fits all; it is deeply contextual. Testing activities
are very context-specific and depend largely on the nature of the software under
consideration. For instance, when reviewing an e-commerce website’s database reporting,
testers use various strategies to explore it. No two software products are identical, and this
calls for a bespoke testing strategy that reflects the special features of each product.

2. Early Testing
Understanding testing as a lifelong endeavor rather than a separate stage, early testing
becomes one of the key principles in agile development. This approach entails testing
requirements before the coding phase so that testers can identify problems early and save
time as well as money. By testing early in the software’s life cycle, potential errors are
reduced, facilitating a more efficient and cost-effective approach to programming.

3. Defect Presence
Testing acts as the mechanism that emphasizes that defects are present rather than proves
their complete absence. Testing unquestionably brings the defect down considerably, but it
does not proclaim a faultless, error-free system. Instead, it creates confidence in the
viability of software, ensuring users that it has been properly reviewed and therefore
deployed into production with higher levels of assurance.

4. Exhaustive Testing:
It also recognizes the fact that exhaustive testing is impossible due to time and financial
constraints. The ideal scenario is testing as many applications as possible, but practical
considerations call for making priorities. To address this limitation, skillful risk assessment
and test planning become essential to ensuring a pragmatic as well as effective testing
approach amid resource constraints.
5. Defect Clustering:

Defect clustering is an occurrence in many complex systems. By using the Pareto principle,
the 80-20 rule, testers can concentrate on the critical 20% of codes leading to an advantage
of nearly 80% inconsistencies. This is especially the case in big systems or those relying on
components from a third party. Defect clusters will be identified and improved upon when
advancing systems with new functions.

6. Fallacy of Absence of Error:

Contrary to the stereotypical misconception of the total absence of errors, this principle
focuses on the fact that there is value in designing systems with nothing going wrong only if
they meet users’ needs. The point is to understand and test software in a way that meets
users’ expectations. The collaborative testing with end-users ensures that the software’s
usability is what they need.

7. Pesticide Paradox:
Using a comparison from the realm of plants and insecticides, the so-called pesticide
paradox indicates that their tests become less productive repeatedly. On the one hand, like
pests developing immunity, testers need to diversify testing practices to reveal new
problems and errors. Continuous diversity in the methods of testing avoids stagnancy and
ensures that the changing complexities of software are appropriately identified.

These seven principles underlie a strong software testing philosophy that recognizes the
unpredictability and changing nature of developing an application. Embracing these
principles lends testing practices the transformation to a strategic and adaptive framework
that supports providing resilient, user-centric, high-quality software products.