Full Stack QA Training

The Full Stack QA Training course at RexGalaxy Academy is a complete 8-month program for learners who want to build a strong career in software testing, QA engineering, automation testing, API testing, mobile QA, and SDET-oriented roles. This course is designed for students, freshers, manual testers, career switchers, and working professionals who want a complete path instead of learning only one tool.

The program begins with software testing foundations and quality mindset, then moves into SDLC, STLC, Agile process, manual testing, test design, documentation, web testing, mobile QA awareness, SQL database validation, API testing with Postman, programming basics, Selenium WebDriver automation, Page Object Model framework design, reporting, Appium basics, Git, CI/CD awareness, defect tracking, QA operations, and a capstone portfolio project.

Key learning highlights:

• Understand complete QA workflow from requirement analysis to test planning, test design, execution, defect reporting, regression, release support, and QA metrics.

• Build strong manual testing skills with test scenarios, test cases, checklists, traceability, bug reports, execution evidence, and professional documentation.

• Learn SQL and backend validation so students can verify database records, logs, API outputs, and system behavior beyond the visible UI.

• Practice API testing with Postman, REST concepts, collections, environments, authentication basics, response validation, and API test documentation.

• Learn Selenium WebDriver automation, locators, waits, assertions, Page Object Model, reusable utilities, reports, screenshots, logs, and framework structure.

• Gain awareness of Appium mobile automation basics, Git workflow, CI/CD pipelines, test management tools, defect tracking, and QA operations used in real teams.

By the end of this course, learners can work across manual QA, web QA, backend validation, API testing, automation framework building, mobile QA basics, and project documentation. The final goal is to make students confident enough to explain a full-stack QA project in interviews and show practical evidence through reports, screenshots, SQL/API validations, automation scripts, and GitHub documentation.

This module builds the base for the complete QA journey. Students learn what software testing is, why quality assurance matters, and how QA professionals think about risk, business requirements, user behavior, and release confidence.

Topics covered:

• Meaning of software quality, testing purpose, QA versus QC, verification versus validation, and the role of testers in software teams.

• Functional testing, non-functional testing awareness, smoke testing, sanity testing, regression testing, retesting, exploratory testing, usability testing, and compatibility testing.

• Requirement understanding, testable requirements, business flow mapping, risk identification, positive and negative scenarios, and user-focused thinking.

• Test levels including unit, integration, system, acceptance, and end-to-end testing from a QA perspective.

• Defect basics, severity, priority, defect lifecycle, defect evidence, reproducibility, and communication with developers.

• QA mindset: curiosity, attention to detail, structured thinking, documentation discipline, and release responsibility.

Practical outcome:

• Students can explain testing fundamentals clearly and start thinking like professional QA engineers rather than only tool users.

This module explains how QA work fits inside real software development teams. Learners understand the complete lifecycle of a software project and how testing activities are planned, executed, tracked, and reported.

Topics covered:

• SDLC models including waterfall awareness, iterative development, Agile, Scrum, sprint planning, daily standups, sprint review, and retrospective.

• STLC phases including requirement analysis, test planning, test design, environment setup, test execution, defect reporting, regression, closure, and metrics.

• Agile QA responsibilities, sprint QA, story testing, acceptance criteria, definition of done, release readiness, and collaboration with developers and product owners.

• Test plan basics, scope, assumptions, risks, entry criteria, exit criteria, deliverables, timelines, and resource planning.

• Test estimation, test execution status, daily QA updates, defect triage, QA sign-off, and release notes awareness.

• Professional QA communication and how to give clear status without confusion.

Practical outcome:

• Students can understand how QA teams operate in Agile projects and how testing work is managed from requirement to release.

This module develops strong manual testing and documentation ability. Students learn how to convert requirements into useful test scenarios, test cases, checklists, and execution evidence.

Topics covered:

• Test scenario writing, test case writing, preconditions, test steps, expected results, actual results, test data, priority, and execution status.

• Test design techniques including equivalence partitioning, boundary value analysis, decision table awareness, state transition awareness, error guessing, and exploratory testing.

• Checklist-based testing for UI, forms, login pages, search flows, dashboards, reports, validations, permissions, and common web/mobile screens.

• Traceability matrix basics, requirement coverage, test coverage, execution coverage, and gap identification.

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

• Test summary reports, daily execution reports, defect summary, retest evidence, regression evidence, and QA closure documentation.

Practical outcome:

• Students can prepare professional QA documents and execute manual testing with clear evidence and reporting discipline.

This module teaches practical testing for web and mobile applications. Students learn how to test user interfaces across browsers, devices, screen sizes, operating systems, and common real-world conditions.

Topics covered:

• Web UI testing for forms, buttons, links, navigation, layout, data validation, error messages, sessions, roles, search, filters, uploads, downloads, and reports.

• Responsive testing, browser compatibility, device compatibility, screen-size checks, rendering issues, alignment, usability, and accessibility awareness.

• Mobile QA concepts including Android and iOS awareness, native apps, hybrid apps, web apps, app installation, permissions, interruptions, orientation, network changes, and device coverage.

• Cross-browser testing strategy using browser matrix, OS coverage, browser version awareness, and critical flow selection.

• Common production defect areas such as broken validations, session expiry issues, duplicate submissions, slow pages, incorrect messages, and inconsistent UI behavior.

• Test evidence collection using screenshots, screen recordings, logs, browser console awareness, and device notes.

Practical outcome:

• Students can test web and mobile applications more completely and document browser/device-specific behavior properly.

This module gives QA learners the backend validation skills needed for full-stack testing. Students learn how to verify data beyond the UI using SQL queries and database thinking.

Topics covered:

• Database fundamentals, tables, rows, columns, primary keys, foreign keys, relationships, and basic database terminology for testers.

• SQL queries including SELECT, WHERE, ORDER BY, DISTINCT, LIKE, IN, BETWEEN, LIMIT, aggregate functions, GROUP BY, and basic joins.

• Data validation after UI actions such as registration, login, form submission, order creation, profile update, and status changes.

• Backend verification using database records, audit fields, timestamps, flags, status columns, and relationship checks.

• Comparing UI data with database data, identifying mismatches, duplicate records, missing records, and incorrect calculations.

• SQL practice for QA interview scenarios and common database validation tasks used in web applications.

Practical outcome:

• Students can write basic SQL queries and validate backend data as part of full-stack QA testing.

This module teaches API testing from a QA perspective. Students learn how frontend, backend, and APIs connect, and how to validate responses using Postman before moving into automation awareness.

Topics covered:

• API fundamentals, REST concepts, endpoints, request methods, headers, query parameters, path parameters, payloads, status codes, and response bodies.

• Postman setup, collections, environments, variables, request creation, response validation, collection runner, and test organization.

• Validating GET, POST, PUT, PATCH, and DELETE requests with positive and negative test cases.

• Authentication awareness including tokens, bearer auth, cookies, session handling, and environment-specific values.

• API response checks including status code, response body, response time awareness, schema awareness, mandatory fields, error messages, and business rules.

• API defect reporting, API evidence collection, Postman documentation, and connecting API checks with UI testing.

Practical outcome:

• Students can test REST APIs using Postman and explain API test cases, validations, and defects confidently.

This module introduces the programming foundation required for Selenium automation and framework work. Students learn practical coding concepts used by automation testers, with a focus on writing reusable and readable test code.

Topics covered:

• Java or Python programming basics depending on the learning path: variables, data types, operators, conditions, loops, strings, arrays or lists, methods, and functions.

• Object-oriented programming concepts including classes, objects, constructors, inheritance awareness, encapsulation, and reusable methods.

• Collections, files, exception handling, debugging, console output, code flow reading, and common beginner mistakes.

• Writing reusable utilities for test data, waits, screenshots, logging, browser setup, file reading, random data, and date handling.

• Clean code habits including naming conventions, folder organization, comments, modular logic, and avoiding repeated code.

• Automation-focused practice problems that connect programming logic with QA test scenarios.

Practical outcome:

• Students can write simple, reusable code and are ready to build automation scripts with Selenium WebDriver.

This module teaches browser automation using Selenium WebDriver. Students learn how to automate real web application flows with stable locators, waits, assertions, screenshots, and controlled execution.

Topics covered:

• Selenium WebDriver setup, browser drivers, browser launch, navigation, page title, URL validation, and session handling.

• Locators including id, name, class, link text, CSS selector, XPath, dynamic XPath, and locator best practices.

• Web element actions such as click, type, clear, get text, get attribute, dropdowns, checkboxes, radio buttons, tables, alerts, frames, windows, tabs, and file upload awareness.

• Synchronization using waits, handling delayed elements, stale elements, loading screens, dynamic content, and avoiding unreliable fixed delays.

• Assertions, validation checkpoints, screenshots on failure, logs, test evidence, and failure analysis.

• Automating practical flows such as login, search, form submission, validation errors, user roles, and regression scenarios.

Practical outcome:

• Students can write Selenium automation scripts and troubleshoot common browser automation failures.

This module turns individual automation scripts into a professional framework. Students learn how to structure automation projects so they are maintainable, reusable, and interview-ready.

Topics covered:

• Automation framework architecture, folder structure, base classes, page classes, test classes, utilities, configuration files, test data, reports, logs, and screenshots.

• Page Object Model design, page methods, reusable actions, base page utilities, locator repositories, and separation of test logic from page logic.

• TestNG or PyTest concepts including setup, teardown, assertions, grouping, parameterization, suites, fixtures or annotations, and controlled execution.

• Data-driven testing using Excel, CSV, JSON, or framework-supported sources with positive and negative data sets.

• Reporting using HTML reports, screenshots on failure, execution logs, pass/fail summaries, timestamps, and result analysis.

• Framework documentation for GitHub including README, setup steps, command-line execution, report samples, and project architecture explanation.

Practical outcome:

• Students can build and explain a reusable automation framework with POM, utilities, data handling, and reports.

This module introduces mobile automation awareness using Appium. Students learn how mobile automation differs from web automation and how QA teams approach Android and iOS automation basics.

Topics covered:

• Appium overview, mobile automation purpose, Appium server, drivers, clients, sessions, and basic architecture awareness.

• Android automation basics, emulator and real device awareness, APK handling, app package, app activity, permissions, and device setup concepts.

• iOS automation awareness, simulator workflow, WebDriverAgent concept, signing limitations, and accessibility identifiers.

• Mobile locators including accessibility ID, resource ID, text, class, XPath, Android UIAutomator awareness, and iOS predicate/class chain awareness.

• Mobile gestures such as tap, long press, swipe, scroll, orientation changes, keyboard handling, alerts, and app state changes.

• How mobile automation fits into a full QA role and how Appium connects with Selenium-style automation thinking.

Practical outcome:

• Students understand Appium basics and can explain mobile automation workflow, tools, locators, and common challenges.

This module connects QA work with professional team workflows. Students learn how QA artifacts, automation code, defects, reports, and release checks are managed in real organizations.

Topics covered:

• Git fundamentals including repository, clone, status, add, commit, push, pull, branch awareness, merge awareness, and GitHub project documentation.

• Test management tools such as Jira or similar platforms, test case organization, defect tracking, sprint boards, status updates, and QA dashboards.

• CI/CD awareness including Jenkins or GitHub Actions concepts, build triggers, scheduled runs, artifacts, test reports, and release pipeline checks.

• QA operations including smoke testing, regression planning, release validation, defect triage, QA sign-off, metrics, and stakeholder communication.

• Understanding logs, screenshots, reports, build numbers, environment details, app versions, browser versions, and device details in QA evidence.

• Team workflow: developer handoff, retesting, regression impact, production issue analysis, and continuous improvement.

Practical outcome:

• Students can work more confidently in real QA teams and understand how testing connects with Git, CI/CD, test management, and release operations.

The final module brings the complete Full Stack QA journey together through a portfolio-ready project and interview preparation. Students prepare practical proof of their learning across manual testing, SQL, API, Selenium automation, framework design, and QA process.

Topics covered:

• Capstone planning with application selection, requirement analysis, test scenario list, test cases, test data, execution plan, and defect examples.

• Creating manual QA deliverables including test cases, checklists, bug reports, execution summary, traceability awareness, and release notes awareness.

• Adding SQL validations, API test collections, Postman evidence, Selenium automation scripts, framework structure, reports, screenshots, and logs.

• Preparing GitHub documentation with README, tools used, setup steps, folder structure, execution commands, report samples, screenshots, and known limitations.

• Resume preparation for manual testing, SQL, API testing, Selenium automation, framework design, Appium basics, Git, CI/CD awareness, and QA operations.

• Interview preparation with common questions, project explanation, defect discussion, framework walkthrough, API validation examples, SQL scenarios, and mock QA workflow explanation.

Practical outcome:

• Students complete the course with a full-stack QA portfolio and the confidence to explain practical QA work in interviews.