Manual Testing + Selenium Automation

Manual Testing + Selenium Automation is a complete QA training program for students who want to build both manual testing confidence and practical Selenium automation skills. The course starts with software testing fundamentals, SDLC, STLC, requirement analysis, test cases, defect reporting, agile workflow, Jira awareness, web testing, API and database basics, then moves into Selenium WebDriver, locators, waits, framework design, reports, Git, CI/CD awareness and capstone portfolio work.

Key learning focus:

• Understand quality assurance, tester responsibilities, SDLC models, STLC phases, requirement analysis, test planning and QA documentation.

• Prepare professional manual testing documents including test 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 and use case testing.

• Learn defect lifecycle, severity, priority, evidence collection, retesting workflow and professional bug communication.

• Understand agile testing basics, Jira-style workflow, user stories, acceptance criteria, web testing areas, API testing awareness and database validation basics.

• Start Selenium automation with WebDriver setup, browser control, navigation, element interaction, assertions, screenshots and stable script structure.

• Build reliable locators using DOM inspection, ID, name, class name, tag name, link text, CSS selectors and XPath.

• Handle dynamic web applications using waits, synchronization, alerts, frames, windows, file uploads, scrolling and advanced UI actions.

• Organize automation using test runners, assertions, fixtures or hooks, grouping, parametrization and controlled test execution.

• Build Page Object Model frameworks with reusable pages, utilities, configuration files, reports, logs, screenshots, Git workflow and portfolio documentation.

Students complete guided manual testing documents, Selenium scripts, locator suites, stable UI tests, execution frameworks, POM framework work, data-driven tests, reports, screenshots and a final QA capstone that can be explained during interviews and portfolio reviews.

This module builds the foundation of software testing, quality mindset, project lifecycle understanding and testing workflow. Students learn how QA fits into real projects and how testers contribute from requirement review to release support.

Topics covered:

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

• Software testing role with tester mindset, observation skill, requirement understanding, risk thinking, communication discipline and practical ownership.

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

• STLC phases covering requirement analysis, test planning, test case design, environment setup, execution, defect reporting, retesting and closure.

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

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

• Requirement analysis using BRD, SRS, user stories, acceptance criteria, business rules, assumptions, gaps and clarification questions.

• Test planning basics including scope, objectives, schedule, roles, risks, resources, test environment, deliverables and approval workflow.

• QA documentation including test plan, test scenarios, test cases, defect reports, traceability matrix, test summary and daily status reports.

• Labs for requirement review exercise, STLC flow mapping, test type classification, risk list preparation and sample QA document creation.

Learning outcome:

• Students can explain QA fundamentals, testing lifecycle, documentation flow and tester responsibilities with confidence.

Students learn how to convert requirements into clear manual testing deliverables. This module focuses on test scenarios, detailed test cases, checklists, traceability, execution records, reporting discipline and organized QA workflow.

Topics covered:

• Manual testing purpose including hands-on application verification, user behavior review, business rule validation and risk-based testing decisions.

• Test scenario writing with major flows, alternate flows, negative flows, boundary situations, dependency areas and business priorities.

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

• Positive and negative cases using valid inputs, invalid inputs, missing data, special characters, wrong formats and error message validation.

• Checklist design for UI checklist, form checklist, login checklist, payment checklist awareness, responsive checks and basic accessibility review.

• Traceability matrix connecting requirements to scenarios, scenarios to test cases, defects to requirements and coverage to release readiness.

• Test data preparation including valid data, invalid data, boundary data, duplicate data, dependency data and safe handling of sensitive information.

• Test execution process with build selection, environment check, smoke testing, execution tracking, blocked cases, retesting and regression planning.

• Reporting discipline including daily execution status, pass and fail count, pending cases, blocked items, risk notes and clear summary communication.

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

Learning outcome:

• Students can prepare professional manual testing documents and execute test cycles in an organized QA workflow.

This module teaches practical test design methods and defect management skills so students can create stronger test coverage and communicate bugs professionally. The focus is on reducing missed defects and building clear evidence-based QA communication.

Topics covered:

• Test design need including reducing missed defects, increasing coverage, avoiding random testing and making test cases stronger with structured techniques.

• Boundary value analysis using minimum, maximum, just below, just above, valid range, invalid range and form field validation examples.

• Equivalence partitioning with valid classes, invalid classes, grouping similar inputs, reducing duplicate cases and increasing meaningful coverage.

• Decision table testing for business rules, condition combinations, action mapping, payment or discount logic and policy-based scenarios.

• State transition testing with status changes, login attempts, workflow states, order status, approval flow and invalid transition checks.

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

• Defect lifecycle covering new, assigned, open, fixed, retest, reopened, deferred, rejected, duplicate, closed and verified workflow.

• Bug report writing with clear title, steps to reproduce, expected result, actual result, environment, screenshots, logs, severity and priority.

• Severity and priority using business impact, technical risk, release urgency, blocker, critical, major, minor and practical classification examples.

• Labs to apply test design techniques, classify defects, write high-quality bug reports, attach evidence and perform retesting workflow.

Learning outcome:

• Students can design stronger test cases, report defects professionally and explain bug impact with proper QA terminology.

Students learn modern QA environments beyond simple test cases, including agile workflow, Jira awareness, web application behavior, API checks and database validation basics. This module helps connect manual testing with real project tools and technical testing awareness.

Topics covered:

• Agile testing basics including scrum roles, sprint planning, backlog refinement, user stories, acceptance criteria, daily standup, review and retrospective.

• Jira awareness covering issue types, epics, stories, tasks, bugs, workflow status, comments, attachments, filters, dashboards and sprint boards.

• Web application basics including browser, client-server flow, HTTP request and response, cookies, sessions, cache, forms, links and page rendering.

• UI testing areas including layout, spelling, alignment, navigation, buttons, validation messages, responsiveness, browser compatibility and usability checks.

• API testing awareness including endpoint, method, request body, response body, status code, headers, authentication, JSON and basic validation.

• Postman awareness with creating requests, sending parameters, inspecting responses, checking status code, saving collections and documenting API behavior.

• Database testing basics including tables, rows, columns, keys, SQL select queries, data validation, record checks and safe read-only verification.

• Basic SQL for testers including SELECT, WHERE, ORDER BY, LIKE, COUNT, joins awareness, null checks, duplicate checks and data comparison.

• Environment awareness including QA, staging, production, build version, test data, access credentials, deployment notes and release readiness checks.

• Labs to test a web form, log Jira-style bugs, verify API responses, run basic SQL checks and prepare an agile test status note.

Learning outcome:

• Students understand modern QA project flow and can connect manual testing with web, API, database and agile practices.

This module starts browser automation with Selenium WebDriver. Students learn why automation is used, how to set up tools, how WebDriver controls browsers and how manual test cases can be converted into repeatable scripts.

Topics covered:

• Automation overview including why automate, what to automate, what not to automate, regression value, repeatability, maintenance and ROI awareness.

• Selenium WebDriver role including browser control, user action simulation, application verification, driver commands and web automation workflow.

• Tool setup including programming language environment awareness, IDE setup, browser setup, Selenium package, browser driver and project folder planning.

• First script flow with creating driver, opening URL, maximizing browser, verifying title, navigating pages, closing browser and handling cleanup correctly.

• Browser commands including get, back, forward, refresh, current URL, title, page source awareness, close, quit and session handling.

• Driver configuration including browser options, headless awareness, download settings, timeouts, window size and stable execution settings.

• Automation script structure with setup, test steps, assertion, evidence, cleanup, reusable constants and avoiding hard-coded fragile values.

• Common setup errors including browser mismatch, path issue, dependency issue, session failure, NoSuchDriver awareness and practical troubleshooting.

• Manual to automation mapping by converting executed manual test cases into repeatable Selenium flows with clear validation points.

• Labs to install tools, run first Selenium script, automate login flow, verify page title, capture basic evidence and close session safely.

Learning outcome:

• Students can start Selenium automation correctly and convert simple manual scenarios into reliable browser automation scripts.

Students learn how to inspect web pages, create reliable locators, interact with WebElements and validate browser behavior. This module is central to writing Selenium scripts that are stable and understandable.

Topics covered:

• DOM understanding including HTML tags, attributes, text, forms, buttons, links, tables, nested elements, dynamic attributes and browser inspection.

• Locator strategies including ID, name, class name, tag name, link text, partial link text, CSS selector, XPath and choosing reliable locators.

• CSS selector practice including ID selector, class selector, attribute selector, parent-child selection, contains-style patterns and clean readable locators.

• XPath practice including relative XPath, text function, contains, starts-with awareness, axes basics, indexing and avoiding unstable absolute XPath.

• WebElement methods including click, send keys, clear, submit awareness, get text, get attribute, get CSS value and basic property checks.

• Element state validation including displayed, enabled, selected, checked, unchecked, disabled fields, hidden elements and validation message behavior.

• Form automation with input fields, buttons, radio buttons, checkboxes, dropdowns, date fields, file fields and multi-step form flows.

• Table handling including rows, columns, dynamic values, cell reading, search result validation, pagination awareness and data comparison.

• Locator maintenance with naming locators, storing selectors, avoiding fragile values, reviewing DOM changes and improving test stability.

• Labs to inspect pages, create locator sheet, automate form controls, validate table data, test checkbox and dropdown flow and debug locator failures.

Learning outcome:

• Students can interact with web elements confidently and build stable locators for real Selenium automation.

Students learn how to handle timing issues and advanced user interface behavior that commonly causes Selenium tests to fail. The module covers waits, dynamic pages, alerts, frames, windows, uploads, downloads and complex browser interactions.

Topics covered:

• Synchronization problems including page load delay, AJAX calls, animations, loaders, delayed elements, dynamic DOM updates and flaky test behavior.

• Wait types including implicit wait, explicit wait, fluent wait awareness, polling, timeout management and when each wait approach is suitable.

• Expected conditions such as element visible, clickable, presence located, text present, frame available, alert present and URL or title checks.

• Dynamic element handling including changing IDs, stale elements, refresh behavior, delayed search suggestions, auto-complete and retry-safe logic.

• Alerts and popups including simple alert, confirmation alert, prompt alert, accept, dismiss, text reading and safe validation workflow.

• Frames and iframes including switching to frame, switching back, nested frame awareness, frame locator strategy and common frame automation mistakes.

• Multiple windows and tabs including window handles, switching context, verifying titles, closing child windows and returning to parent window.

• Actions class concepts including mouse hover, drag and drop awareness, right click, double click, keyboard actions and composite UI behavior.

• JavaScript executor awareness including scroll, click fallback, retrieving values, handling hidden behavior carefully and avoiding unnecessary JavaScript usage.

• Labs to automate dynamic search, handle alert, switch frames, switch windows, upload file, scroll page and fix flaky wait failures.

Learning outcome:

• Students can handle complex web pages and reduce automation failures caused by timing and dynamic UI behavior.

Students learn how to organize Selenium automation using execution frameworks, assertions, setup-teardown logic, fixtures or hooks, groups, parameters and controlled test execution. This module converts scripts into professional test suites.

Topics covered:

• Framework need including organized execution, reduced manual running effort, improved reporting, controlled setup and repeatable test suites.

• Test runner concepts including test methods, annotation awareness, setup, teardown, before and after hooks, grouping, suites and execution order.

• Assertions including hard assertions, soft assertions awareness, expected vs actual comparison, meaningful messages and validation discipline.

• Fixtures and hooks including browser setup, login setup, data setup, cleanup, reusable initialization and reliable test isolation.

• Parametrization for running the same test with multiple datasets, reducing duplicate code, increasing coverage and keeping logic readable.

• Test grouping including smoke, sanity, regression, priority-based execution, module-wise execution and selective test runs.

• Retry and flaky test awareness including retry caution, root cause analysis, wait correction, test data review and avoiding false confidence.

• Command-line execution including running tests from terminal, pass options, selecting groups, generating outputs and supporting CI execution later.

• Framework options awareness including TestNG, JUnit, PyTest, unittest, behave basics and selecting based on project technology.

• Labs to create test suite, add assertions, setup and teardown, parameterized execution, grouped test run and failure review.

Learning outcome:

• Students can organize Selenium tests with a professional execution structure and clear validation logic.

Students learn how to build maintainable Selenium frameworks using Page Object Model, reusable utilities, configuration files, clean folder structures and version control awareness. This module makes automation portfolio-ready and easier to maintain.

Topics covered:

• Framework architecture including separate tests, pages, locators, utilities, data, configuration, reports, screenshots, logs and driver setup.

• Page Object Model with page classes, WebElement methods, action methods, validation methods, reusable flows and reduced duplication.

• Base page design with common click, type, wait, find, scroll, screenshot, dropdown, frame and window handling methods.

• Configuration management including URL, browser, timeout, environment, credentials awareness, file paths and safe settings control.

• Reusable utilities including data reader, screenshot helper, report helper, log helper, browser factory, wait utility and cleanup helper.

• Folder structure with clean package naming, test module naming, page naming, resource folders, output folders and predictable file organization.

• Coding standards including readable names, small methods, useful comments, reusable constants, avoiding duplication and simple maintainable code.

• Framework debugging including broken locators, wrong page object flow, missing waits, dependency issues, data issues and configuration mismatch.

• Version control awareness including meaningful commits, gitignore, README, requirements or dependency file, branch workflow and review habits.

• Labs to build login page object, create base page, add config file, add utilities, run page object tests and refactor duplicate code.

Learning outcome:

• Students can build maintainable Selenium frameworks that look clean, reusable and portfolio-ready.

Students learn how to make automation data-driven and evidence-friendly using external data, reports, screenshots, logs and failure analysis. This module connects automation execution with professional QA evidence.

Topics covered:

• Data-driven testing purpose including running the same business scenario with multiple datasets and separating test logic from input values.

• External data files including Excel, CSV, JSON, text files, config files, environment files and selecting the right data source.

• Excel and CSV awareness including headers, rows, columns, sheet names, valid data, invalid data, boundary data and repeated scenario execution.

• JSON and config awareness including structured data, environment settings, nested values, API-style data and readable framework configuration.

• Data strategy including reusable accounts, unique data, cleanup rules, invalid data, duplicate data, sensitive data safety and stable test design.

• Reports overview including pass, fail, skipped, error, duration, environment, browser, screenshots, logs and readable summary for stakeholders.

• Screenshot handling including failure screenshots, step screenshot awareness, timestamp naming, folder organization and evidence mapping.

• Logging basics including info, warning, error, debug messages, file logs, console logs and avoiding passwords or sensitive details in logs.

• Failure analysis including screenshot review, stack trace reading, test data check, environment check, locator review and root cause note writing.

• Labs to run login tests from Excel or CSV, add config file, capture screenshot on failure, generate basic report and prepare evidence folder.

Learning outcome:

• Students can create data-driven automation with clear reports, logs, screenshots and professional test evidence.

Students learn how automation fits into team operations, cross-browser coverage, version control, CI/CD awareness, troubleshooting and QA maintenance. This module prepares students to discuss automation in a project environment, not only as isolated scripts.

Topics covered:

• Cross-browser testing including Chrome, Firefox, Edge awareness, browser versions, rendering differences, compatibility risk and coverage planning.

• Parallel execution awareness including speed benefit, test independence, shared data risk, browser resource limits and avoiding session conflicts.

• Selenium Grid awareness including hub and node concept, remote WebDriver, browser capability setup, distributed execution and Grid use cases.

• Headless execution including benefits, limitations, debugging differences, CI usefulness and when visible browser execution is better.

• Git workflow including repository setup, commits, branches, README, gitignore, version history, collaboration awareness and portfolio presentation.

• CI/CD awareness including Jenkins, GitHub Actions, triggered runs, scheduled runs, artifacts, reports, screenshots and environment variables.

• QA operations including build verification, smoke suite, regression suite, release support, test summary, sign-off awareness and production caution.

• Maintenance workflow including updating locators, updating data, reviewing failed builds, managing flaky tests and creating improvement backlog.

• Team communication including defect notes, automation reports, release status, blocker communication and evidence-based QA updates.

• Labs to push framework to GitHub, run cross-browser test, prepare CI checklist, review failure logs and write automation status report.

Learning outcome:

• Students can manage automation like a team project with source control, browser coverage, CI awareness and QA reporting.

The final module brings manual testing and Selenium automation together into a complete portfolio project. Students prepare manual deliverables, automation deliverables, capstone scenarios, GitHub documentation, interview explanations and career direction.

Topics covered:

• Capstone planning including application selection, scope definition, manual test cases, automation candidates, data plan and module-wise coverage.

• Manual testing deliverables including requirement notes, scenarios, test cases, RTM, defect report samples, execution sheet and test summary report.

• Automation deliverables including Selenium framework, page objects, reusable utilities, data-driven tests, screenshots, logs, reports and run guide.

• Capstone scenarios including login, registration, search, filter, cart awareness, form validation, table validation, user workflow and negative testing.

• Portfolio documentation including README, tool setup, folder structure, execution steps, report screenshots, known limitations and improvement plan.

• Interview topics including SDLC, STLC, test cases, defect lifecycle, severity, priority, Selenium commands, locators, waits, POM, reports and Git.

• Scenario practice covering broken locator, timeout, stale element, invalid login, missing requirement, duplicate defect, flaky test and failed build.

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

• Career direction for manual tester, QA engineer, Selenium automation tester, test analyst, automation trainee and SDET foundation path.

• Final demo with manual documents, Selenium suite execution, report explanation, screenshot evidence, question handling and improvement discussion.

Learning outcome:

• Students deliver a complete Manual Testing plus Selenium portfolio project and can explain it confidently in interviews.