Start in QA
Build software-testing and quality-assurance foundations.
Testing · Quality assurance and defect prevention
Software Testing
Learn software testing concepts, SDLC and STLC, test design techniques, test-case writing, execution, defect management, reporting, and quality assurance practices.
Move from testing fundamentals to a complete Test Plan & Execution project with test scenarios, test cases, defect reports, traceability, execution results, and a presentation-ready outcome.
Course overview
Software testing helps ensure that applications meet requirements, work as expected, and provide a reliable experience for users. It involves planning, designing, executing, and reporting tests to identify defects before software reaches users.
This course introduces software-testing fundamentals, SDLC and STLC, testing levels and types, requirements analysis, test scenarios, test cases, test-design techniques, execution, defect lifecycle, bug reporting, traceability, regression testing, and test reporting.
The proposed capstone is a Test Plan & Execution project covering test scenarios, test cases, execution results, defect reports, traceability, and a professional presentation.
Effective testing is more than finding bugs. It helps teams understand risk, validate requirements, improve quality, and make informed release decisions.
Prerequisites
This course is designed for learners with basic computer knowledge. No prior testing experience is required.
- Basic computer knowledge.
- Basic English reading and writing skills.
- Basic logical thinking and attention to detail.
- Basic understanding of websites or mobile apps is helpful.
- Basic spreadsheet knowledge is helpful.
- No prior testing experience is required.
Readiness activity
Choose a website or mobile app. Identify one feature, describe how it should work, and list two situations where it might fail.
Who can explore this course?
Learn QA skills
Develop practical testing and problem-solving skills.
Enter technology
Build a foundation for QA and software-testing pathways.
Improve quality
Learn structured testing practices for business applications.
What you will learn
- Explain software testing and quality-assurance fundamentals.
- Understand SDLC, STLC, and the testing process.
- Distinguish verification and validation.
- Understand testing levels, types, and techniques.
- Analyze requirements and identify test conditions.
- Write clear test scenarios and test cases.
- Apply boundary value analysis and equivalence partitioning.
- Execute tests and record actual results.
- Identify, report, and track defects.
- Understand defect severity, priority, and lifecycle.
- Use traceability between requirements and test cases.
- Perform regression and retesting.
- Prepare test-summary and defect reports.
Curriculum outline
The ten-module outline moves from software-testing fundamentals to a complete Test Plan & Execution project. Exact tools, templates, and practice applications should be confirmed before delivery.
01
Software testing fundamentals
Understand the purpose and principles of software testing.
- Software quality and testing overview.
- Testing objectives and principles.
- Errors, defects, and failures.
- Verification and validation.
- Quality assurance versus quality control.
- Testing mindset and attention to detail.
Practice: Identify examples of an error, defect, and failure in a sample application workflow.
02
SDLC and STLC
Understand how testing fits into the software-development and testing lifecycle.
- Software Development Life Cycle.
- Software Testing Life Cycle.
- Requirement analysis.
- Test planning.
- Test-case development.
- Environment setup.
- Execution and closure.
Practice: Map the stages of SDLC and STLC for a simple application feature.
03
Testing levels and types
Understand different testing levels and common testing types.
- Unit, integration, system, and acceptance testing.
- Functional and non-functional testing.
- Smoke and sanity testing.
- Regression and retesting.
- Usability and compatibility testing.
- Performance and security-testing concepts.
Practice: Classify sample testing activities into testing levels and types.
04
Requirements and test design
Analyze requirements and create effective test conditions.
- Requirement analysis.
- Functional and business requirements.
- Test conditions and test scenarios.
- Positive and negative testing.
- Boundary value analysis.
- Equivalence partitioning.
Practice: Analyze a login requirement and create test scenarios using positive and negative cases.
04
Test cases and documentation
Write clear, reusable, and traceable test cases.
- Test-case structure.
- Test-case ID and title.
- Preconditions and test data.
- Test steps and expected results.
- Priority and test type.
- Test-case review.
Practice: Write test cases for a registration, login, or search feature using a standard template.
05
Test execution
Execute test cases and record accurate results.
- Test-environment readiness.
- Test execution process.
- Actual versus expected results.
- Pass, fail, blocked, and skipped statuses.
- Evidence and screenshots.
- Execution reporting.
Practice: Execute a set of test cases and record results with notes and evidence.
05
Defect management
Identify, document, and track software defects effectively.
- Defect identification.
- Defect lifecycle.
- Defect report structure.
- Severity and priority.
- Defect triage.
- Defect verification and closure.
Practice: Write a clear defect report with steps, expected result, actual result, severity, and priority.
06
Traceability and coverage
Link requirements, test cases, and defects for better coverage.
- Requirements traceability matrix.
- Requirement-to-test-case mapping.
- Test coverage concepts.
- Coverage gaps.
- Impact analysis.
- Change management.
Practice: Create a traceability matrix linking requirements, scenarios, and test cases.
06
Regression and retesting
Validate fixes and ensure existing functionality remains stable.
- Retesting concepts.
- Regression testing concepts.
- Smoke and sanity checks.
- Test selection and prioritization.
- Regression risks.
- Release-readiness considerations.
Practice: Identify which test cases should be retested and which should be included in regression testing after a fix.
07
Reporting and quality practices
Communicate testing results clearly and support release decisions.
- Test-summary report.
- Defect report and metrics.
- Test progress and exit criteria.
- Risk-based testing.
- Test documentation.
- Professional communication.
Practice: Prepare a test-summary report with execution status, defects, risks, and recommendations.
08
Capstone delivery
Complete the Test Plan & Execution project and prepare a professional demonstration.
- Define the application and testing scope.
- Identify users, features, and business rules.
- Analyze requirements and identify test conditions.
- Create a test plan.
- Write test scenarios and test cases.
- Execute test cases and record results.
- Report and track defects.
- Create a traceability matrix.
- Perform retesting and regression testing.
- Prepare a test-summary report and presentation.
Practice: Submit a complete Test Plan & Execution project with test artifacts, defect reports, and a presentation.
Practical exercise ideas
Complete these smaller activities before assembling the final Test Plan & Execution project.
Requirement analysis
Identify test conditions from a sample requirement.
Login test cases
Write positive and negative test cases for a login feature.
Boundary testing
Apply boundary value analysis to an age or amount field.
Test execution sheet
Execute test cases and record actual results.
Bug report
Write a clear defect report with severity and priority.
Test summary
Prepare a test-summary report with results and risks.
Suggested six-week learning plan
This is an illustrative learning sequence. Confirm the academy's official timetable, tools, templates, and assessment requirements before publishing.
| Week | Focus | Suggested milestone |
|---|---|---|
| 01 | Testing fundamentals and SDLC/STLC | Explain testing concepts and the testing lifecycle. |
| 02 | Testing levels and types | Classify testing activities by level and type. |
| 03 | Requirements and test design | Create test scenarios and test cases. |
| 04 | Execution and defect management | Execute tests and write defect reports. |
| 05 | Traceability, regression, and reporting | Create a traceability matrix and test-summary report. |
| 06 | Capstone presentation | Submit and present the Test Plan & Execution project. |
Turn requirements into tested quality
Capstone project
Test Plan & Execution
Build a Test Plan & Execution project for an approved web or mobile application. Possible examples include an e-commerce site, banking-style application, learning portal, task-management app, registration system, or another suitable educational application.
Core project requirements
- Define the application, users, and testing scope.
- Identify key features, business rules, and risks.
- Analyze functional and business requirements.
- Create a test plan with objectives, scope, approach, and schedule.
- Identify test scenarios for major user flows.
- Write positive and negative test cases.
- Use boundary value analysis and equivalence partitioning where appropriate.
- Include preconditions, test data, steps, and expected results.
- Execute test cases and record actual results.
- Use pass, fail, blocked, and skipped statuses correctly.
- Report defects with clear steps and evidence.
- Assign severity and priority appropriately.
- Create a requirements traceability matrix.
- Perform retesting and identify regression test cases.
- Prepare a test-summary report and presentation.
Quality requirements
- Use clear and meaningful test-case titles.
- Use one clear validation objective per test case where practical.
- Use realistic and non-confidential test data.
- Use clear preconditions and step-by-step instructions.
- Use measurable expected results.
- Use correct test statuses and evidence.
- Use clear defect titles and reproducible steps.
- Use severity and priority appropriately.
- Use traceability to show requirement coverage.
- Use risk-based prioritization for test execution.
- Use professional language and documentation.
- Document assumptions, limitations, and recommendations.
A strong test plan should define what will be tested, how it will be tested, who will test it, what evidence will be collected, and what conditions must be met before release.
Suggested project structure
Keep requirements, test plans, test cases, execution results, defects, and reports organized.
test-plan-and-execution/
├── 01-requirements/
│ ├── business-requirements.md
│ ├── functional-requirements.md
│ └── user-stories.md
├── 02-test-planning/
│ ├── test-plan.docx
│ ├── test-strategy.md
│ └── risk-assessment.xlsx
├── 03-test-design/
│ ├── test-scenarios.xlsx
│ ├── test-cases.xlsx
│ └── traceability-matrix.xlsx
├── 04-test-execution/
│ ├── execution-results.xlsx
│ ├── screenshots/
│ └── test-evidence/
├── 05-defects/
│ ├── defect-log.xlsx
│ └── defect-reports/
├── 06-reports/
│ ├── test-summary-report.docx
│ └── defect-summary.xlsx
└── README.md
Do not include personal data, confidential business information, real customer records, or production credentials in test documentation.
Software-testing workflow
Software testing is iterative. Requirement changes, new defects, fixes, and release decisions may require updates to test cases, execution plans, defect reports, or coverage.
Understand requirements
Identify features, rules, risks, and test conditions.
Define the approach
Define scope, strategy, schedule, roles, and exit criteria.
Create test cases
Write scenarios, test cases, and traceability links.
Run tests
Execute tests, record results, and collect evidence.
Manage defects
Report defects, track fixes, and verify resolutions.
Review quality
Prepare reports and support release decisions.
A good test case should have a clear objective, repeatable steps, defined test data, and a measurable expected result.
Tools and technologies
The exact tools and templates may vary by delivery. The proposed toolkit focuses on practical manual software-testing workflows.
- Test plans
- Test scenarios
- Test cases
- Test data
- Defect reports
- Traceability matrices
- Microsoft Excel
- Google Sheets
- Jira concepts
- Bug-reporting concepts
- Browser DevTools
- Screenshots
Supporting concepts
- SDLC, STLC, and testing principles.
- Testing levels, types, and techniques.
- Requirements analysis and test design.
- Test execution, defect lifecycle, and reporting.
- Traceability, regression, and release readiness.
- Risk-based testing and quality communication.
Learning outcomes
By completing the proposed lessons and exercises, aim to demonstrate the following abilities:
- Explain software-testing and quality-assurance fundamentals.
- Understand SDLC, STLC, and the testing process.
- Distinguish testing levels, types, and techniques.
- Analyze requirements and identify test conditions.
- Write clear test scenarios and test cases.
- Execute tests and record accurate results.
- Identify, report, and track defects.
- Use traceability and coverage practices.
- Perform retesting and regression testing.
- Prepare test-summary and defect reports.
These are learning objectives, not guarantees of employment, certification, placement, or a specific QA role. Progress depends on practice, attention to detail, communication, and continued learning.
Related career interests
Illustrative directions for continued learning, not job or placement guarantees.
- Manual Tester
- QA Engineer Trainee
- Software Tester Trainee
- Quality Analyst Trainee
- Test Coordinator Trainee
- Technology Trainee
- Support / Implementation Engineer
Portfolio presentation ideas
- Explain the application, users, and testing scope.
- Show the test plan and risk-based approach.
- Present test scenarios and test cases.
- Explain execution results and defect reports.
- Show traceability and coverage.
- Discuss limitations and recommendations.
Frequently asked questions
Who is this course for?
It is suitable for beginners, students, career changers, and professionals who want to learn software testing and quality assurance.
Do I need programming experience?
No. This course focuses on manual software-testing concepts and does not require programming experience.
Do I need technical knowledge?
Basic computer knowledge is sufficient. Basic knowledge of websites, mobile apps, and spreadsheets is helpful.
Will the course cover SDLC and STLC?
Yes. It covers the Software Development Life Cycle, Software Testing Life Cycle, and the stages of the testing process.
Will the course cover test cases?
Yes. It covers test-case structure, test scenarios, test data, preconditions, steps, expected results, and test-case review.
Will the course cover test-design techniques?
Yes. It covers positive and negative testing, boundary value analysis, and equivalence partitioning.
Will the course cover defect management?
Yes. It covers defect identification, defect lifecycle, defect reports, severity, priority, triage, and closure.
Will the course cover regression testing?
Yes. It covers retesting, regression testing, smoke testing, sanity testing, and release-readiness considerations.
Will the course cover traceability?
Yes. It covers requirements traceability matrices, requirement-to- test-case mapping, coverage, and coverage gaps.
What is the capstone project?
The proposed capstone is a Test Plan & Execution project covering test scenarios, test cases, execution, defect management, traceability, and reporting.
Which tools are used?
The proposed tools include test-plan templates, test-case templates, defect logs, Microsoft Excel, Google Sheets, and Jira concepts. Confirm the academy's selected tools before enrollment.
How long is the course?
The supplied course information proposes a duration of six weeks. Confirm the academy's official schedule, tools, practice applications, and assessment requirements.
Does this course guarantee a job?
No. The course can support practical learning and portfolio development, but it does not guarantee employment, placement, certification, or salary.
How do I enroll?
This page is a frontend course-information demonstration. Enrollment, payment, scheduling, and admission workflows are not implemented here.
Build quality through structured testing
Build your testing project
Study software-testing fundamentals, test design, execution, defect management, and reporting through a practical Test Plan & Execution project.