Error (Human mistake):

An error is a mistake made by a developer during coding or

logic design.
Example:
The developer writes if(score > 60) instead of if(score >= 60).
➡ This is an error in logic.

Bug (Fault in code):

A bug is a fault in the software code that causes the system to
behave unexpectedly during execution.
Example:
Because of the above error, students who scored exactly 60 are
marked "Fail" instead of "Pass".
➡ This is a bug found while running the program.

Defect (Mismatch with requirement):

A defect is a difference between the actual result and the
expected result, found during testing.
Example:
The requirement says “Users must receive a confirmation email
after signup,” but no email is sent.
➡ This is a defect found during testing.

Agile : agile is a flexible & fast software development

method where work is done in small parts with regular
feedback & quick improvement

Product Owner : A Product Owner is the person who

defines what to build and in what order,
Example: They decide to build the login page before the profile
page based on user needs.

Scrum Master : A Scrum Master is the person who guides

the team to follow Scrum practices and removes any blockers.
Example: If developers are stuck due to unclear requirements,
the Scrum Master arranges a meeting with the Product Owner
to resolve it.

Agile Team : An Agile team is a cross-functional group of

professionals (like developers, testers, designers) who work
together to deliver small, working parts of a product in short
cycles.
Example: A team of 6 members builds and delivers a working
shopping cart feature in one sprint.
Sprint : A Sprint is a short, fixed period (usually 1–4 weeks) in
Agile during which a team builds and delivers a usable part of
the product.
Example: The team developed and tested the user registration
feature in a 2-week sprint.

Scrum : is an Agile framework that organizes work into short

cycles (sprints) with defined roles and meetings to deliver and
improve the product continuously.
Example: A team using Scrum holds daily stand-ups, works in 2-
week sprints, and delivers a new feature at the end of each
sprint.

Burndown chart :A Burndown Chart is a graph that

shows how much work is left in a sprint and helps track
progress toward the sprint goal.
Example: If tasks decrease daily on the chart, the team is on
track to finish on time.

Product Backlog: Product Backlog is a list of all features,

enhancements, bug fixes, and technical tasks needed for a
product, prioritized by the product owner.

Example:
A to-do list like: "Add search bar", "Fix login bug", "Improve
page speed" — all in one place.
Prioritize backlog: A prioritized backlog is a list of product
features, bugs, or tasks arranged in order of importance, so the
team works on the most valuable items first.

Verification – :
Before development starts, the team checks the
requirement document (SRS) and design to make sure
everything is correct and complete.
Example:
• QA reviews the login flow diagram to ensure it matches
the client’s requirement.
• Developer checks if the API list has proper
request/response formats before coding.

Validation -:
After the software is built, testers actually run the app to
see if it behaves correctly.
Example:
Tester logs into the app with valid and invalid data to check if
login works as expected.
Client tests the “Add to Cart” feature and confirms the total
price is correct.
QA (Quality Assurance) : is about preventing defects by
improving the process.
Example: Creating a test plan before development to ensure
quality steps are followed.
QC (Quality Control) : is about finding defects in the actual
product.
Example: Testing the login page and reporting a bug when
incorrect login still allows access.

SDLC(Software Development Life Cycle ) Phases :--

Client Requirement Meeting
Talk to the client/stakeholders to understand exactly what
they need.
Example: "We want an e-commerce website with online
payment and admin panel."
Requirement Document (SRS - Software Requirement
Specification)
Write all features, functions, and rules in a clear document
for team reference.
Example: Login must work with email or phone; payment via
UPI.
Design (UI/UX + Architecture)
Designers make screen designs (Figma, Adobe XD) and
developers plan structure.
Example: Homepage layout, database schema, API design.
Environment Setup
Developers set up tools like Git, VS Code, database, and
backend servers.
Example: Create repo on GitHub, install required packages,
connect database.
Development (Frontend + Backend)
Developers start coding features in parts — frontend UI,
backend logic, and APIs.
Example: Create product page, search feature, cart logic, login
API.
Unit Testing (by Developers)
Developers test their own code (small pieces) to ensure it's
working properly.
Example: Check if product API returns correct results.
Integration Testing (by Testers)
QA team checks that all parts work together smoothly.
Example: Add-to-cart works after login and calculates correct
total.
Integration Testing (by Testers)
QA team checks that all parts work together smoothly.
Example: Add-to-cart works after login and calculates correct
total.
Bug Fixing + Feedback Loop
QA reports bugs → devs fix → QA retests until clean.
Example: Fixing "payment fails on 2nd attempt" issue.
UAT (User Acceptance Testing)
Client or Product Owner tests the software to confirm it
meets needs.
Example: Client logs in, places orders, checks invoice – gives OK.
Deployment
Code is pushed to live server (e.g., AWS, Azure) or Play
Store/Web.
Example: E-commerce site goes live at [Link].
Maintenance + Updates
Fix live issues, add new features, and monitor performance.
Example: Add coupons after 1 month or fix real user bugs.

STLC (Software Testing Life Cycle) –

Requirement Analysis
QA team reads the SRS (Requirement Doc) to understand
what to test.
Example: Is login required? Are there password rules?
1. Test Planning
QA Lead prepares the test strategy, decides tools,
timeline, and who will test what.
Example: Manual testing or automation? Who tests login?
Who tests payment?
2. Test Case Design
Testers write test cases based on the requirements.
Example: Write test steps for valid login, invalid login,
empty fields, etc.
3. Test Environment Setup
DevOps or QA team sets up the testing environment
(test server, DB, tools).
Example: Load the test build on a staging server with
sample data.
4. Test Execution
Testers execute the test cases and mark Pass/Fail.
Example: Run test cases on login form — login fails? Report
bug.
5. Defect Reporting
Found bugs are logged in Jira or other tools with
screenshots and steps.
Example: "Login accepts wrong password – severity: High"
 6. Test Closure
After fixing and retesting, QA prepares a test summary
report.
Example: Out of 30 test cases, 27 passed, 3 failed and were
fixed.

Levels of Testing --:

1. Unit Testing
Testing individual units/components of code in isolation.
Example: A developer tests the login() function separately using
test data.
2. Integration Testing
Testing how two or more modules work together after
combining.
Example: Checking if the login module properly connects with
the dashboard module after login.
Top-Down Approach
Testing starts from top modules and goes downward, using
stubs for unfinished lower modules.
Example: Testing the main menu module while using a stub to
mimic the login module it calls.
2. Bottom-Up Approach
Testing starts from lower-level modules first, using drivers to
simulate higher modules.
Example: Testing the login logic first and using a driver to
simulate the call from the dashboard.
3. Hybrid (Sandwich) Approach
A mix of top-down and bottom-up — both high-level and low-
level modules are tested together.
Example: Testing login and dashboard together while still using
stubs/drivers for unfinished parts.
Stub
A fake/dummy module that replaces a called (low-level)
module not yet developed.
Example: If the payment module isn't ready, use a stub to
return "Payment Successful" during testing.

Driver
A fake/dummy module that simulates a calling (high-level)
module not yet developed.
Example: If the cart module isn't ready to call checkout, a driver
manually calls the checkout code for testing.

3. System Testing
Testing the complete software as a whole in an environment
similar to production.
Example: QA tests the full app flow — login, cart, checkout,
payment.
4. Acceptance Testing
Final testing done to ensure the software meets business
requirements.
Example: The client tests if the "Place Order" feature works as
they expected.