Software Testing · Terminology
Software Testing Terminology Every Beginner Should Learn
Quick summary — software testing terminology
The software testing terminology beginners need most falls into three groups: process terms, test types and defect terms. Know the STLC, test plans and test cases; understand smoke, sanity, regression and UAT; and be able to explain severity versus priority and the defect life cycle. These come up in almost every testing interview.
In this guide you will learn:
- Process terms — STLC, test plan, test case, test data.
- Test types — smoke, sanity, regression, UAT and more.
- Defect terms — severity, priority and the defect life cycle.
- A term practice sheet — template for revision.
- Tips — learning terms through real testing.
SECTION 01Process terms: how testing is organised
Testing is not random clicking. Teams follow a process, often called the Software Testing Life Cycle (STLC), with phases from understanding requirements to closing the test cycle. Each phase produces documents or artefacts with specific names. Knowing these terms helps you follow conversations in your first week and answer process questions in interviews.
| Term | Plain meaning | Example | When it is used |
|---|---|---|---|
| STLC | Phases of testing from requirements to closure | Requirement analysis → test closure | Throughout a project |
| Test plan | Document describing scope, approach, schedule and risks | Test plan for release 2.4 | Before testing starts |
| Test case | Steps, data and expected result for one check | TC-01: valid login opens dashboard | Test design phase |
| Test data | Inputs used to run test cases | Valid and invalid email addresses | Design and execution |
Test Case ID : TC-LOGIN-01
Title : Login with valid credentials
Preconditions: User qa_user exists and is active
Test data : email = qa_user@example.com
password = Valid@123
Steps : 1. Open login page
2. Enter email and password
3. Click "Log in"
Expected : Dashboard opens; user name shown at top
Actual :
Status : Pass / Fail1. Requirement analysis - understand what to test
2. Test planning - scope, approach, effort, risks
3. Test case design - write cases and prepare data
4. Environment setup - get a test environment ready
5. Test execution - run cases, log defects
6. Test closure - summary report, lessons learnedSECTION 02Test types: what kind of testing is this?
Test types answer "why are we testing now?" Smoke testing checks that a new build is stable enough to test at all. Sanity testing checks a specific fix or small change. Regression testing makes sure existing features still work after changes. User Acceptance Testing (UAT) is done by business users to confirm the software meets their needs. Beginners often mix these up, so interviewers love asking about them.
| Term | Plain meaning | Example | When it is used |
|---|---|---|---|
| Smoke testing | Quick broad check that the build is testable | App opens, login works, main pages load | Every new build |
| Sanity testing | Narrow check of a specific fix or change | Verify the fixed coupon bug only | After a small fix |
| Regression testing | Re-checking existing features after changes | Full checkout suite after a payment change | Before releases |
| UAT | Business users confirm it meets their needs | Finance team approves new invoice screen | Before go-live |
# pytest markers let you run only the smoke tests
import pytest
@pytest.mark.smoke
def test_home_page_loads(client):
assert client.get("/").status_code == 200
@pytest.mark.smoke
def test_login_page_loads(client):
assert client.get("/login").status_code == 200
# Run only smoke tests: pytest -m smoke
# Register the marker in pytest.ini:
# [pytest]
# markers = smoke: quick build verification testsFunctional - does the feature do what it should?
Non-functional - performance, security, usability
Black-box - testing without seeing the code
White-box - testing with knowledge of the code
Exploratory - learning and testing at the same time
Integration - do modules work together?
System - testing the complete application
Retesting - re-running a failed case after a fixSECTION 03Defect terms: reporting what is wrong
When a test fails, you raise a defect (also called a bug). Two fields confuse beginners: severity and priority. Severity is how badly the defect affects the system; priority is how urgently it should be fixed. They usually move together but not always. A defect also moves through a life cycle from new to closed, and each status has a meaning everyone on the team understands.
| Term | Plain meaning | Example | Why it matters |
|---|---|---|---|
| Defect / bug | Difference between expected and actual behaviour | Total ignores coupon | Basis of quality reports |
| Severity | Impact on the system | App crashes = critical | Shows how serious it is |
| Priority | Urgency of fixing | Wrong logo on home page = high priority | Guides fixing order |
| Defect life cycle | Statuses a bug moves through | New → Assigned → Fixed → Retest → Closed | Shared tracking language |
High severity, low priority:
App crashes on a rarely used legacy report screen
that will be removed next month.
Low severity, high priority:
Company name misspelt on the home page before a
big marketing launch.
High severity, high priority:
Payment fails for all users at checkout.
Low severity, low priority:
Tooltip text slightly misaligned on one settings page.New -> tester logs the defect
Assigned -> lead assigns it to a developer
Open -> developer starts working on it
Fixed -> developer says it is fixed
Retest -> tester re-runs the failed case
Closed -> fix confirmed
Reopened -> issue still present after "fix"
Other statuses: Rejected, Duplicate, DeferredSECTION 04Testing terminology practice sheet
Use this sheet to revise and test yourself before interviews.
Explain in one line each:
1. STLC
2. Test plan vs test strategy
3. Smoke vs sanity
4. Retesting vs regression
5. Severity vs priority
6. Black-box vs white-box
7. UAT
8. Defect life cycle
Check your answers against this guide.Which test type is this?
a) New build arrives; you check app opens and login works
b) A coupon bug was fixed; you check only coupons
c) Payment code changed; you re-run all checkout cases
d) Finance users try the new invoice screen before go-live
Answers: a) smoke b) sanity c) regression d) UATFront: Severity Back: How badly it affects the system
Front: Priority Back: How urgently it must be fixed
Front: Test data Back: Inputs used to execute a test case
Front: Exploratory Back: Learning and testing at the same time
Front: Integration Back: Testing how modules work togetherSECTION 05Tips for learning testing terminology
Terms stick when you use them on real software:
- Test a real app — write five test cases for any app you use daily.
- Log one defect properly — with steps, expected and actual results.
- Use examples for confusing pairs — smoke vs sanity, severity vs priority.
- Read real bug reports — open-source projects publish them openly.
- Explain terms aloud — interviews are spoken, so practise speaking.
SECTION 06Interview Q&A — software testing terminology
Q1What is the difference between smoke and sanity testing?
Smoke testing is a broad, shallow check that a new build is stable enough for further testing. Sanity testing is a narrow check that a specific fix or change works as expected.
Q2Explain severity and priority with an example.
Severity is impact; priority is urgency. A crash on a rarely used screen may be high severity but low priority, while a misspelt company name on the home page before launch may be low severity but high priority.
Q3What is regression testing and why is it important?
It re-runs tests on existing features after changes to make sure nothing that worked before has broken. It protects quality as software keeps changing.
Q4What are the phases of the STLC?
Requirement analysis, test planning, test case design, test environment setup, test execution and test closure.
Q5What is the difference between retesting and regression testing?
Retesting checks that a specific defect is fixed by re-running the failed case. Regression testing checks that the change has not broken other features.
SECTION 07Test yourself — software testing terminology quiz
Five questions. No sign-up.
0 / 5Pick an answer to see why it is right or wrong.
SECTION 08Frequently asked questions
What are the basic terms in software testing?
Start with STLC, test plan, test case, test data, defect, severity, priority, smoke testing, sanity testing, regression testing and UAT. They appear in almost every testing role.
What is the difference between a test plan and a test strategy?
A test strategy is a high-level approach, often at organisation or product level. A test plan applies that approach to a specific project or release with scope, schedule, resources and risks.
What is a test scenario?
A test scenario is a high-level description of something to test, such as "user can reset password". One scenario usually leads to several detailed test cases.
Is software testing terminology the same everywhere?
Core concepts are widely shared, often following ISTQB definitions, but some companies use slightly different names or statuses. Understanding the meaning matters more than the label.
How do I remember software testing terms for interviews?
Learn them in confusing pairs, attach a real example to each, practise scenario questions and explain them aloud.
SECTION 09Related reads
Classroom & online · Noida
Learn testing terms by testing real software
Our Software Testing Training Course covers STLC, test design, defect management, test types and real project practice, so every term becomes something you have done.
Talk to a counsellor for current fees- Manual testing foundations
- Test case and defect practice
- Live project testing
- Weekday & weekend batches