Manual Testing Training

Manual Testing Training is a practical QA program for students who want to build strong manual testing, documentation, defect reporting, web testing, API basics, SQL validation and release support skills. The course is designed for learners preparing for manual tester, QA analyst, software tester and test engineer roles.

Key learning focus:

• Learn QA fundamentals, SDLC, STLC, testing types, testing levels, tester responsibilities and real project QA workflow.

• Understand requirement analysis, business rules, assumptions, gaps, scope, risks, test strategy and test planning.

• Prepare professional QA documents including test plans, scenarios, test cases, checklists, RTM, execution sheets, defect reports and test summary reports.

• Apply test design techniques such as boundary value analysis, equivalence partitioning, decision tables, state transition testing, use case testing, pairwise awareness and error guessing.

• Report defects with clear evidence, severity, priority, reproducible steps, environment details, screenshots, logs and retesting notes.

• Test web, mobile and UI applications for forms, navigation, responsiveness, compatibility, validation messages, accessibility, usability and content accuracy.

• Understand API testing basics, Postman-style workflows, status codes, JSON validation, authentication awareness and API evidence collection.

• Use simple SQL concepts for testers to validate records, stored values, report data, backend changes and database-related defects.

• Work with agile testing, Jira-style issue tracking, sprint QA process, daily status reporting, regression planning and release support.

• Complete practical labs and a capstone portfolio with requirement review, test cases, checklists, defect samples, API or SQL checks, reports and presentation.

Students complete practical manual testing projects they can explain during interviews, counselling sessions, demos and portfolio reviews.

This module builds the software testing foundation required for manual QA work. Students learn quality mindset, project lifecycle awareness, STLC flow, testing types, testing levels and the responsibilities of a tester in real teams.

Topics covered:

• Quality assurance overview including quality, verification, validation, defect prevention, customer expectations and tester responsibility in projects.

• Testing mindset with observation, curiosity, requirement understanding, risk thinking, communication discipline and attention to user experience.

• Software testing purpose including finding defects early, verifying business rules, reducing production risk, improving reliability and supporting confident releases.

• SDLC models including waterfall, V model, iterative, spiral awareness, agile workflow, release cycle and how testing fits into each phase.

• STLC phases including requirement analysis, test planning, test case design, environment setup, execution, defect reporting, closure and lessons learned.

• Testing levels including unit, integration, system, end-to-end, UAT awareness, entry criteria, exit criteria and handoff between project teams.

• Testing types including smoke, sanity, functional, regression, retesting, exploratory, usability, compatibility, acceptance and non-functional awareness.

• QA roles including manual tester, QA analyst, test lead awareness, business analyst interaction, developer interaction and product owner communication.

• Basic deliverables including test plan, scenarios, test cases, RTM, defect report, execution sheet, test summary and daily QA status notes.

• Labs to map SDLC and STLC, classify testing types, review a sample requirement, prepare QA glossary and create a testing workflow chart.

Learning outcome:

• Students can explain QA fundamentals, SDLC, STLC, testing levels, testing types and tester responsibilities with confidence.

Students learn how to read and analyze requirements before test execution begins. This module develops the ability to identify gaps, define scope, estimate effort, prepare test strategy and plan testing work professionally.

Topics covered:

• Requirement reading including business goals, user flow, functional rules, non-functional expectations, assumptions, dependencies and exclusions.

• Requirement sources including BRD, SRS, user stories, acceptance criteria, wireframes, emails, product notes, change requests and client discussions.

• Clarification process to identify gaps, contradictions, missing fields, unclear validations, dependency questions and business rule conflicts.

• Scope definition including in-scope features, out-of-scope areas, supported devices, supported browsers, test depth, risks and release priorities.

• Test strategy basics including testing approach, test levels, test types, roles, environment needs, data needs, tools, schedule and reporting plan.

• Test plan contents including objective, scope, resources, assumptions, risks, deliverables, entry criteria, exit criteria, suspension criteria and approvals.

• Estimation awareness including module size, test case count, complexity, risk level, resource availability, retesting effort and regression effort.

• Risk analysis with high-impact features, critical workflows, payment or login areas, data loss risk, security risk and production business impact.

• Traceability thinking with requirements to scenarios, scenarios to test cases, defects to requirements and coverage to release readiness.

• Labs to analyze sample SRS, write clarification questions, define test scope, prepare risk list and create a simple test plan outline.

Learning outcome:

• Students can analyze requirements, plan testing work, identify risks and prepare a professional foundation before execution begins.

Students learn how to convert requirements into clear test scenarios, detailed test cases, checklists, test data and execution records. This module focuses on writing documents that another tester can understand and execute.

Topics covered:

• Test scenario writing including major flows, alternate flows, negative flows, boundary situations, user journeys and important business priorities.

• Test case structure including test case ID, title, precondition, steps, test data, expected result, actual result, status, priority and remarks.

• Positive test cases for valid input, correct workflow, expected messages, successful submission, proper navigation and complete transaction paths.

• Negative test cases for invalid input, empty fields, wrong formats, missing permissions, duplicate values, interrupted flows and error messages.

• Checklist preparation including UI checklist, login checklist, form checklist, payment checklist awareness, validation checklist and release checklist.

• Test data design including valid data, invalid data, boundary data, duplicate data, dependency data, reusable data and privacy-safe handling.

• Execution sheet fields such as build version, test case status, tester name, execution date, comments, defect links, blocked cases and retesting status.

• RTM basics including requirement ID, scenario ID, test case ID, defect ID, status, coverage percentage and release traceability evidence.

• Review quality including clear wording, step-by-step flow, no ambiguity, proper expected result, reusable data and easy execution by another tester.

• Labs to write scenarios, create detailed test cases, prepare checklists, build RTM, execute sample cases and create execution status report.

Learning outcome:

• Students can prepare complete manual testing documents that are readable, traceable, executable and useful for real QA projects.

This module teaches structured test design methods that improve coverage, reduce missed defects and make manual testing more systematic. Students learn how to design stronger cases rather than relying on random checking.

Topics covered:

• Test design need including avoiding random testing, improving coverage, reducing duplicate cases, finding hidden defects and making testing systematic.

• Boundary value analysis with minimum, maximum, just below, just above, valid range, invalid range and field-length validation examples.

• Equivalence partitioning with valid classes, invalid classes, grouping similar inputs, reducing case count and improving meaningful coverage.

• Decision table testing for multiple conditions, business rule combinations, discount logic, permission logic, payment rules and action mapping.

• State transition testing for login attempts, order status, approval flow, ticket status, password reset and valid or invalid status movement.

• Use case testing with actor, main flow, alternate flow, exception flow, preconditions, postconditions and acceptance validation.

• Pairwise awareness for combinations of browsers, devices, roles, input types, settings and reducing large test combinations practically.

• Error guessing based on tester experience, common mistake patterns, missing validations, user behavior issues and high-risk areas.

• Coverage review including requirement coverage, field coverage, workflow coverage, risk coverage, regression coverage and missed-case analysis.

• Labs to apply BVA, EP, decision table, state transition, use case testing and coverage review on sample modules.

Learning outcome:

• Students can design stronger test cases using professional techniques and explain why each test case is important.

Students learn how to identify, document, prioritize, track, retest and close defects with professional evidence and communication. This module builds the bug reporting discipline required in real QA teams.

Topics covered:

• Defect meaning including mismatch between expected and actual result, requirement gap, usability issue, environment issue and production risk.

• Bug life cycle including new, assigned, open, fixed, retest, reopened, verified, closed, rejected, duplicate, deferred and cannot reproduce.

• Bug report structure including title, environment, build version, steps to reproduce, test data, expected result, actual result, evidence and notes.

• Severity classification including blocker, critical, major, minor, cosmetic, business impact, technical risk, user impact and data impact.

• Priority classification including urgent release need, business importance, customer impact, sprint priority, workaround availability and fix planning.

• Evidence collection using screenshots, screen recordings, logs, console messages, network notes, database proof and exact user steps.

• Retesting process including confirming fix, using same steps, verifying evidence, checking related areas, updating status and communicating result clearly.

• Regression relation including deciding whether fixed defect can affect other modules, planning nearby checks and avoiding repeated issue leakage.

• Bug communication with clear language, no blame, useful technical details, reproducible steps, polite comments and professional follow-up.

• Labs to find defects, write strong bug reports, classify severity and priority, attach evidence, retest fixes and close defects correctly.

Learning outcome:

• Students can report defects professionally and communicate bug impact, reproduction steps, evidence and closure status with clarity.

Students learn how to test real user interfaces across web and mobile-facing applications. The module focuses on forms, navigation, responsiveness, compatibility, validation messages, usability, accessibility and content accuracy.

Topics covered:

• Web testing basics including browser behavior, client-server flow, page load, links, buttons, forms, navigation, cookies, sessions and cache awareness.

• UI testing with layout, spelling, alignment, font consistency, color consistency, labels, icons, spacing, image quality and responsive display.

• Form testing with mandatory fields, optional fields, placeholders, input length, formats, validation messages, reset behavior and submission flow.

• Navigation testing including menus, breadcrumbs, links, back button behavior, redirects, broken links, pagination, filters, search and page titles.

• Mobile testing basics including screen sizes, orientation, touch behavior, mobile browser behavior, responsive layout and device compatibility awareness.

• Compatibility testing across Chrome, Firefox, Edge, Safari awareness, OS differences, mobile browsers, screen resolutions and browser-specific issues.

• Usability checks including clear instructions, easy flow, readable messages, simple actions, user-friendly errors and reduced confusion.

• Accessibility awareness including alt text, keyboard navigation, label clarity, contrast awareness, focus visibility and basic inclusive design checks.

• Content validation including spelling, grammar, pricing, images, terms, messages, contact details, policy links and business information accuracy.

• Labs to test login page, registration form, menu navigation, responsive page, broken links, validation messages and UI checklist.

Learning outcome:

• Students can test web and mobile-facing applications carefully with UI, usability, compatibility and user-flow awareness.

This module introduces API testing concepts and Postman-style workflows for manual testers. Students learn how to validate backend communication, status codes, headers, JSON structure, authentication and API defect evidence.

Topics covered:

• API testing purpose including backend communication, business logic, data exchange, integrations, response accuracy and service reliability.

• API basics including endpoint, method, request, response, headers, parameters, body, authentication, status code, JSON and environment URL.

• HTTP methods including GET, POST, PUT, PATCH, DELETE awareness, idempotency basics, request intent and expected response behavior.

• Status codes such as 200, 201, 204, 400, 401, 403, 404, 409, 422 and 500 awareness with tester-friendly meaning.

• Postman workflow including creating request, setting method, adding params, adding headers, adding body, sending request, inspecting response and saving collection.

• JSON validation including key names, values, arrays, nested objects, data type checks, null checks, required fields and response structure.

• Positive and negative API cases including valid token, invalid token, missing field, wrong data type, duplicate data, invalid ID and unauthorized access.

• Authentication awareness including bearer token, API key, basic auth awareness, expired token, missing token and secure handling of credentials.

• API evidence including response screenshot, request details, status code proof, response time note, environment note and defect link.

• Labs to test sample GET and POST APIs, validate JSON fields, check status codes, test invalid input and document API findings.

Learning outcome:

• Students can perform basic API testing using Postman-style workflows and explain API defects clearly to technical teams.

Students learn tester-friendly SQL and database testing concepts to validate backend records, stored values, reports and data integrity. The module focuses on read-only validation and safe practical usage.

Topics covered:

• Database testing purpose including verifying stored values, backend updates, report data, search results, user records, transaction data and data integrity.

• Database basics including tables, rows, columns, primary key, foreign key awareness, records, relationships, schema and application-data connection.

• SQL SELECT basics including SELECT, FROM, WHERE, ORDER BY, LIKE, IN, BETWEEN, DISTINCT, LIMIT awareness and readable query writing.

• Tester query usage including finding records, verifying created data, comparing UI with database, checking status values and validating business fields.

• Data validation including null checks, duplicate checks, format checks, date checks, amount checks, role checks and stored value comparison.

• Join awareness for connecting related tables, understanding customer-order relation, user-role relation and avoiding wrong assumptions from one table.

• Count and summary checks including COUNT, SUM awareness, report totals, dashboard numbers, inventory counts and simple reconciliation cases.

• Safe database practice including read-only testing, no production update, backup awareness, permission boundaries, masking and sensitive data caution.

• Database defect evidence including query used, expected value, actual value, screenshot, environment, record ID and module reference.

• Labs to write SELECT queries, validate form submission data, compare UI and DB values, find duplicates and document DB test results.

Learning outcome:

• Students can use simple SQL confidently to support manual testing, backend validation and defect evidence preparation.

Students learn how manual testers work inside agile teams using stories, sprints, Jira-style boards, test execution, collaboration and release support. This module builds real project process awareness and communication discipline.

Topics covered:

• Agile testing overview including iterative delivery, sprint planning, backlog refinement, daily standup, sprint review, retrospective and continuous testing.

• Scrum roles including product owner, scrum master, development team, QA role, stakeholder interaction and tester contribution in each ceremony.

• User stories including persona, need, benefit, acceptance criteria, business rules, definition of ready and definition of done.

• Sprint testing flow including story understanding, test design, execution, defect reporting, retesting, regression, demo support and sign-off notes.

• Jira basics including projects, epics, stories, tasks, bugs, subtasks, priorities, assignee, labels, attachments, comments and workflow status.

• Test management awareness including test cycle, test set, execution status, defect links, requirement links, dashboards and progress visibility.

• Daily QA status including completed work, pending work, blockers, risks, defects, retesting needs and clear communication to the team.

• Collaboration habits including asking questions early, reporting blockers, providing evidence, joining requirement discussions and communicating release risk.

• Regression planning including sprint regression, release regression, impacted modules, high-risk workflows, smoke suite and priority-based selection.

• Labs to create Jira-style issues, map story acceptance criteria to tests, update execution status and prepare sprint QA summary.

Learning outcome:

• Students can work confidently in agile QA teams using Jira-style workflows, sprint testing discipline and clear status reporting.

Students learn quality checks beyond functional testing, including performance awareness, security basics, compatibility, accessibility, usability, reliability and production readiness. This module helps identify broader quality risks.

Topics covered:

• Non-functional testing overview including performance, security, usability, compatibility, reliability, accessibility, localization and maintainability awareness.

• Performance awareness including page load time, response time, slow pages, heavy images, timeout issues, basic bottleneck observation and user impact.

• Security testing basics including authentication checks, authorization checks, password rules, session timeout, data exposure and input validation awareness.

• Compatibility testing including browsers, devices, operating systems, screen sizes, network conditions, email clients awareness and environment differences.

• Usability review including clear workflow, readable messages, easy navigation, helpful errors, minimal confusion and real user behavior observations.

• Accessibility basics including keyboard access, form labels, focus order, contrast awareness, alt text, screen reader awareness and inclusive testing mindset.

• Localization awareness including date format, currency, language, timezone, text expansion, cultural content and regional validation needs.

• Reliability checks including repeated actions, session continuity, refresh behavior, save behavior, recovery after failure and stable user workflows.

• Production readiness including error page behavior, maintenance messages, tracking links, contact details, policy pages, monitoring awareness and rollback notes.

• Labs to run compatibility checklist, review performance symptoms, check session timeout, inspect accessibility basics and prepare NFR observations.

Learning outcome:

• Students can identify quality risks beyond functional testing and explain non-functional issues in a practical business-friendly way.

Students learn how to execute test cycles, track progress, prepare QA reports, summarize risks and support confident release decisions. This module connects test execution discipline with professional reporting and release sign-off.

Topics covered:

• Test execution preparation including verifying build, environment, credentials, test data, access permissions, release notes and known issues before testing.

• Execution workflow including running smoke tests, executing planned cases, recording results, attaching evidence, raising bugs, retesting fixes and updating status.

• Status tracking including pass, fail, blocked, not run, deferred, retest pending, reopened and completed counts with module-wise visibility.

• Daily reports including work completed, work pending, defects raised, blockers, retesting needs, risk items and next-day testing focus.

• Test summary report including scope tested, builds tested, execution metrics, defect summary, open risks, coverage, limitations and final recommendation.

• Release sign-off awareness including entry criteria, exit criteria, critical bug status, regression status, known issues, business approval and QA recommendation.

• Regression execution including impacted areas, repeated critical flows, defect-prone modules, smoke suite, business-critical cases and release confidence.

• Metrics awareness including test case productivity, defect density, defect leakage, pass percentage, reopen count and module health indicators.

• QA archive including final documents, test evidence, screenshots, defect exports, test summary, release notes and lessons learned.

• Labs to execute a test cycle, update execution sheet, prepare daily status report, create summary report and draft release sign-off notes.

Learning outcome:

• Students can manage test execution end to end and communicate release quality, open risks and QA recommendations professionally.

The final module helps students complete a manual testing portfolio project and prepare interview-ready explanations, resume points and demos. Students learn to present documents, defects, coverage and project decisions confidently.

Topics covered:

• Capstone planning including application selection, scope definition, module identification, test strategy, test data plan and test execution schedule.

• Portfolio deliverables including requirement notes, test plan, scenarios, test cases, checklist, RTM, defect reports, execution sheet and summary report.

• Capstone modules such as login, registration, search, filter, profile, checkout awareness, dashboard, form validation, user roles and reports.

• Defect portfolio with sample bugs, evidence, severity, priority, environment, reproducible steps, actual result and expected result.

• Interview topics including SDLC, STLC, test cases, scenarios, bug life cycle, severity, priority, agile, Jira, API basics, SQL basics and reporting.

• Scenario practice with missing requirement, duplicate defect, blocked test case, production bug, rejected bug, retesting failure and release risk discussion.

• Resume preparation including manual testing skills, tools, project description, documents created, responsibilities and measurable learning outcomes.

• Communication practice including explaining testing approach, defending severity, describing defect impact, discussing risk and answering project questions clearly.

• Career direction for manual tester, QA analyst, software tester, functional tester, test engineer trainee, product QA support and QA coordinator.

• Final presentation to show QA documents, explain test coverage, discuss defects, present summary report, answer questions and describe improvements.

Learning outcome:

• Students deliver a complete manual testing portfolio and confidently explain QA concepts, documents, project work and career goals.