The core theme is to differentiate between verification and validation in software testing, explaining that verification is static testing (checking documentation without executing code) and validation is dynamic testing (executing code to check functionality).
Mind Map
Click to expand
Click to explore the full interactive mind map • Zoom, pan, and navigate
hello everyone welcome again in the
software testing tutorial
we are going to learn the difference
between verification
and validation now this is very
important question
and concept in terms of interviews
so most of the software testing
interviews if you are fresher or even
you know experience in software testing
and you are going for the interview
you will be asked most of the time this
particular question what is the
difference between verification
validation or static testing and dynamic testing
testing
now verification and validation or
verification versus validation
uh is similar to what is static testing
and dynamic testing so verification
is static testing so you can say static
for the verification and validation is
dynamic testing right so this is
also asked what is the difference
between static testing
and dynamic testing right so i'll write
so if somebody asks what is the
difference between verification
and validation or static testing and
dynamic testing
these are the points that you can explain
explain
for both of these questions because verification
verification
is static testing or static testing is
verification and validation is dynamic testing
testing
or dynamic testing is validation right
and this verification
versus validation came from the v model
okay and i'll explain what exactly
verification versus validation means and
what are the difference between
verification and validation okay so
let's start with the point one basically
so here if you see the first point says
process of checking document documents
manually right so
when we say verification verification is
the process
of manual verification or the static verification
verification
so static testing as the name suggests
you do not
execute the code in verification so you basically
basically
go through browse through the
documentation or any uh
documentation that is present or even
the code that is present
for your software right so for example
software requirement documentation
your plans your design documentation the code
code
that is being written by the developers
so the code review happens so when we
say code review
developers have a look at the code and
basically provide the review so they do
not execute but they
just have a look or have a peer review so
so
if i'm i'm a developer and i'm writing
the code i'll send the code for review
to another person maybe my team lead
to have a review right and in the review
the other person will just have a look at
at
the code and he'll see whether i have
followed the best practices
or uh whether all the coding standards
have been followed or not
right so if somebody is verifying
those sort of things without executing
the code
or just going through the plans and
design and
team is basically analyzing whether the
requirement document that is there
it has all the required details in it or
whether there are any gaps
so all those sort of analysis wherein
the execution part is not involved
and manual verification is done is the
verification or
static testing right when we come to
validation validation is basically the
dynamic testing right so when we say validation
validation
in the validation when you have the code
written and the code available
to you as a tester as a package that can
be installed and executed
so in the validation what happens is you
once you get the build
the build is installed in the test
environment and
the actual you actually launch the
application or you
you you know invoke the application
uh by executing the software say for
example if you talk about the e-commerce
website so e-commerce
website if you're building an e-commerce
website so verification will be
going through the requirement document
that is given by the customer
okay but validation will be once those
requirements are
implemented and deployed into the
server and you are actually launching
the web page
or ecommerce portal on the browser so
you are opening the browser
on your computer and you are providing
the url so www whatever name
and hitting enter and then you are
launching that particular web page
that uh you know verify that is
validation right so that is
what dynamic testing is you are actually
launching the url and then you are
actually trying to register or trying to
do the test cases
after launching the application so that
is what validation
is so this is very you know um key
difference that you need to
understand and you can take examples of
e-commerce website or any other examples
that you can think of
right to explain in the interview
so that is the first point now coming to
the second point so verification does
not involve executing the code
so which i've already covered in the
first point so in the verification you
just verify
the documentation say for example you
are going through the requirement or
the design that has been made by the
tech lead tech lead is
walking through the whole team with that
design and taking the feedback
right so that does not involve any code
execution however
in the case of validation as we have
seen that once that design is
implemented into the application
an application is being launched into
the browser
in case of e-commerce website then that
is the
validation because you are doing the
code execution and validating the
functionality right
so when i launch the browser when i hit
the server then there is some
execution that happens behind the scene
and that's when
i'm getting the results on my web page so
so
if there is a code execution involved
then that is validation
right now the third point is basically
in the verification you find bugs or
defects very early
the reason for that is say for example
in the v model as we have seen so
usually b model it will look like this
right let me remove this line here okay
so v model will usually look like a v
okay so here we have the coding okay
if you haven't watched the v model
of software development please go back
and watch the v model
in my previous tutorial in the previous
tutorials of the same series
so you'll understand what exactly view
model is so usually
in the model you have the requirement
right and then you have you know design
different levels of design
phases and you know other design so low
level design
high level design and similarly here you
have the
different phases of testing so unit you
know integration
system and acceptance right
so these these will be the phases so
when we say verification so
anything at this side of this v model
is verification or the testing team's
involvement or
the team that is doing the verification
at this side
of the software development model is
verification okay so this is verification
verification
because here you just have physical you
just have the requirement document and
then that those requirement documents
are being converted into the design documents
documents
then design documents is basically you
know being
converted into the actual code and then
code is reviewed so
all the verification activities happen
in this
you know section here because
team do not actually execute the code
because the code is not ready so code
gets ready here
and in this side of the
v model once the code is ready and the
code is bundled
as the build and available to the test team
team
that's when the actual execution or
dynamic testing starts right so here
it's verification or static testing
so this is static testing in this side
and here
it's dynamic okay so dynamic testing because
because
the code is available as build it will
be deployed and
then you launch the application and
you'll test the application in different phases
phases
that are available here right so this is validation
validation
or dynamic testing okay
so when we talk about the third point
it says bugs and defects are found early
so what it means is because the code
gets ready
very late in the cycle so when you do a
good verification
techniques you are basically going
through the requirement documents
very early in the phase and figuring out
if there are any gaps
and if you are able to find any gaps in
the requirement phase itself
then those gaps will be rectified in the
requirement phase
and they will not flow to the design to
other design and to the code
right so that is why when we say find
defects early in the cycle
this verification helps a lot in finding
defects early
rather than if you do not do the
verification techniques in these phases
what will happen is if there is
something wrong with the requirement
that will go into the design
same design will get implemented into
the code and
the actual defect will be found very
late when the very
when the validation will start somewhere
here with the testing team
so in that particular case if a defect
is found here
then it has to go back and basically
all the way through it has to come back
from the requirement so basically
the requirement has to be updated
because of this defect then design needs
to be changed
right and then accordingly depending on
how severe the defect is
all the phases or the actual fix
that is required to implement that
particular defect
will be a long and it will require a lot
of resources
and money to basically implement that
right but if that same gap is found here
it can be rectified directly
here okay so that is why finding bugs
and defects early in cycle when we say
we do verification because you found the
defects here
or if say for example there is a defined
design defect it can be found
here or low level design defect can be
found here if you are doing
verification right now finding bugs and
defect during dynamic testing phase so in
in
the validation you can only find defects
when you are actually executing the software
software
right so that is why you find bugs
during the dynamic testing phase
uh then the fourth point is again i have
explained cost of defect is less because
you found the defect early in the cycle and
and
if you found the defect early in the
cycle to fix those defect
is really very easy and very
less cost if the same defect flows
through to the later phases of the software
software
development life cycle then that takes
quite a bit of
cost and effort to fix it right so
that's what we have understood as part of
of
point number three right so let me
rub this okay so this diagram is very
important in the interview if you are
trying to explain to the interviewer go through
through
and explain this with confidence with
the examples
okay so understand this what is static
testing dynamic testing validation
verification and then explain with
example and you will be you know like very
very
um you know confident in explaining the
concept okay
so now coming back to the fifth point so
few types of you know testing in the verification
verification
are so basically reviews if you know
about right so code review would have
definitely heard
code review is very widely used right so
if you have worked
even in any software development approach
approach
uh code review is always done so when
the developer writes the code he sends
the code to the peer
or the other team members to basically review
review
for the standards for you know other
aspects of the code
so any sort of reviews technical review
walk through inspection or code review
these are some of the techniques testing techniques
techniques
for verification or static testing okay
now if we talk about the validation um
it is unit testing integration system
acceptance regression and there are many more
more
testing types that you perform
as part of software validation because
all of these
testing here they will require the
actual software built to be available to
be deployed and
you actually execute the code or you run
the software
or launch the software in order to do any
any
sort of any of these testing right so
these are some of the
testing types that you do into the
validation right and these are the
testing type for the verification or the
static testing
okay so these are some of the key points
basically there are many more points and
you can come up with many more
points from the same setup point or
there will be you know if you
give a little bit of thought around
verification validation there will be
many more points that you can
google out over the internet and you
will find
but these are some of the key points
which will be good enough for you to understand
understand
and explain it with example to the
interviewer and this should be
you know more than enough to explain
what is verification validation or
static testing
and dynamic testing and what are the
differences between static testing and
dynamic testing because these are the
key points
that you should know and rest all points
will be you know just an
addition to these points all right so
that's all for this tutorial on
verification and validation or
static testing versus dynamic testing
hope it was helpful and clear please do
share and subscribe and thank you very
Click on any text or timestamp to jump to that moment in the video
Share:
Most transcripts ready in under 5 seconds
One-Click Copy125+ LanguagesSearch ContentJump to Timestamps
Paste YouTube URL
Enter any YouTube video link to get the full transcript
Transcript Extraction Form
Most transcripts ready in under 5 seconds
Get Our Chrome Extension
Get transcripts instantly without leaving YouTube. Install our Chrome extension for one-click access to any video's transcript directly on the watch page.
