QA Engineer
Become a QA engineer — test design, automation frameworks, API and UI testing, CI pipelines, performance testing, and quality strategy. 16 phases from manual testing foundations to SDET-level skills.
Your Progress
Complete all 16 phases to master this track
Become a QA engineer — test design, automation frameworks, API and UI testing, CI pipelines, performance testing, and quality strategy. 16 phases from manual testing foundations to SDET-level skills.
Phase 1: Testing Fundamentals & SDLC
Build a foundation in testing principles, lifecycle stages, test levels, and agile quality practices.
Testing Roles and Core Principles
Define what QA engineers own and the principles that guide effective testing work.
SDLC and the Test Lifecycle
Map test phases onto the software development lifecycle with clear entry and exit criteria.
Test Levels and Test Types
Distinguish unit, integration, system, and acceptance levels plus functional and regression types.
Agile Testing and Shift-Left
Apply agile testing quadrants and shift-left practices to continuous quality in sprints.
Phase 2: Test Planning & Strategy
Author test strategies and plans with risk prioritization, estimation, and measurable coverage metrics.
Writing a Test Strategy
Document scope, approach, resources, environments, and entry-exit criteria for all testing.
Building a Test Plan
Link features to test cases, owners, schedule, risks, and measurable exit criteria.
Risk-Based Test Prioritization
Rank test effort by failure likelihood and business impact using facilitated risk workshops.
Estimation and Coverage Metrics
Estimate effort and track requirement coverage, defect detection, and escape rates.
Phase 3: Test Case Design Techniques
Master equivalence partitioning, boundary analysis, decision tables, and pairwise design methods.
Equivalence Partitioning
Split inputs into partitions and sample representative valid and invalid values.
Boundary Value Analysis
Test just below, at, and just above limits where off-by-one defects typically hide.
Decision Tables and State Transitions
Model logical rules and state sequences to cover complex condition combinations.
Pairwise Combination Testing
Generate compact configuration suites that cover every parameter value pair once.
Phase 4: Bug Lifecycle & Reporting
Run the defect lifecycle, write reproducible bug reports, triage severity, and communicate quality.
Defect Lifecycle States
Follow defects from new through fixed, verified, and closed with agreed transitions.
Writing Reproducible Bug Reports
Craft reports with steps, expected and actual results, environment, and supporting evidence.
Severity, Priority, and Triage
Separate technical severity from business urgency and run effective triage meetings.
Defect Metrics and Stakeholder Reporting
Track trends, leakage, and density, then summarize quality status for stakeholders.
Phase 5: Manual Web & Exploratory Testing
Execute manual web testing with devtools, exploratory charters, and cross-browser device coverage.
Manual Web Testing Workflow
Walk user journeys end to end with structured checklists and session notes.
Testing with Browser DevTools
Inspect network traffic, throttle conditions, console errors, and responsive viewports.
Exploratory Testing and Charters
Run time-boxed charters with heuristics, session notes, and structured debriefs.
Cross-Browser and Device Coverage
Define a support matrix from analytics and verify responsive and input-method behavior.
Phase 6: Automation Foundations
Stand up test automation with framework concepts, Playwright, Selenium, and suite organization.
Automation Concepts and Frameworks
Learn what frameworks organize, when to automate, and how to choose initial tools.
Writing First Playwright Tests
Install Playwright, configure browsers, and author a first passing browser spec.
Selenium WebDriver Basics
Drive browsers with WebDriver sessions, element interactions, and clean teardown.
Structuring an Automation Suite
Organize tests into suites, centralize config, and add a shared helpers layer.
Phase 7: Locators & Waits
Write stable locators, master explicit waits, and debug flaky selector failures.
CSS and XPath Locator Basics
Select elements with CSS selectors and XPath and confirm locator uniqueness.
Robust Locator Strategy
Prefer test ids and accessible names, and document a team-wide locator convention.
Waits and Flakiness Control
Replace fixed sleeps with condition-based waits and quarantine flaky tests properly.
Debugging Failing Tests
Use traces and headed runs to classify product defects versus test or environment bugs.
Phase 8: Page Object Patterns
Encapsulate UI knowledge with page objects, composition, fluent APIs, and data fixtures.
Page Object Basics
Encapsulate selectors and page actions so UI details live in a single maintained place.
Composition and Page Factories
Compose reusable components and construct page instances with factories cleanly.
Fluent Page APIs
Chain page actions into readable fluent calls that express navigation naturally.
Fixtures and Test Data Layers
Provide per-test setup, factories with overrides, isolation, and reliable cleanup.
Phase 9: API Testing
Test REST APIs with Postman and automation, covering auth, status codes, and data-driven runs.
REST Fundamentals with Postman
Learn HTTP methods, status codes, and headers while building organized Postman collections.
Status Codes and Auth Testing
Verify success and error status codes plus token auth failure scenarios.
Automating Postman Collections
Write pm.expect assertions, chain requests with variables, and run via Newman in CI.
Data-Driven API Testing
Drive API tests from JSON or CSV datasets to cover many input permutations cheaply.
Phase 10: Contract & Schema Testing
Protect API contracts with JSON Schema, OpenAPI checks, Pact contracts, and version regression.
JSON Schema Validation
Validate request and response payloads against versioned JSON Schema definitions.
OpenAPI Spec-Driven Testing
Generate tests from an OpenAPI document and diff the spec against the live API.
Consumer-Driven Contract Testing
Use Pact and a broker to fail pipelines before provider changes break consumers.
API Versioning and Compatibility
Guard backward compatibility across versions and communicate deprecation policies.
Phase 11: Mobile Testing
Test mobile apps on devices and emulators, automate with Appium, and run suites on device farms.
Mobile Testing Approaches
Balance emulators and real devices while covering install, upgrade, and interruption flows.
Mobile Automation with Appium
Automate native and hybrid apps with Appium locators, dialogs, and lifecycle handling.
Gestures, Network, and Offline Testing
Verify touch gestures, offline caching, traffic interception, and push deep links.
Device Farms in CI
Shard mobile suites across cloud device farms and track per-model flakiness.
Phase 12: CI/CD Quality Gates & Reporting
Wire tests into CI pipelines, enforce quality gates, manage flakiness, and publish dashboards.
Integrating Tests into CI
Trigger fast suites on pull requests, cache dependencies, and fail builds on errors.
Quality Gates and Merge Policy
Block merges on coverage, severity, and pass criteria with documented waiver paths.
Parallelization and Flaky Test Management
Shard suites across workers, control retries, and maintain an owned quarantine list.
Test Reporting and Dashboards
Publish rich HTML reports, trend charts, and attached failure artifacts to stakeholders.
Phase 13: Performance Testing
Model load with JMeter and k6, set thresholds, and analyze bottlenecks against service objectives.
Performance Concepts and Baselines
Learn latency percentiles, throughput, test types, and how to establish a baseline.
Designing JMeter Test Plans
Build thread groups, samplers, timers, and CSV-driven data in non-GUI load runs.
Load Scripting with k6
Write JavaScript load scripts with scenarios, thresholds, and correctness checks.
Analyzing Results and Bottlenecks
Correlate client latency with server metrics and report SLO-aligned recommendations.
Phase 14: Accessibility & Security Testing Basics
Audit accessibility against WCAG, scan for OWASP risks, and harden auth and session flows.
WCAG Accessibility Fundamentals
Apply WCAG principles with keyboard navigation, contrast, labels, and screen readers.
Automated Accessibility Audits
Run axe-core or Lighthouse in CI and manage accessibility debt with owners.
OWASP Security Testing Basics
Probe injection and XSS risks, avoid error leakage, and audit dependencies.
Auth and Session Security Checks
Validate password policies, token handling, and session invalidation across devices.
Phase 15: SDET Coding Patterns
Write maintainable test code with design patterns, custom matchers, fixtures, and framework architecture.
Design Patterns in Test Code
Apply builder, strategy, and arrange-act-assert structure to keep tests readable.
Custom Matchers and Assertions
Build domain matchers and centralize assertion helpers for clear failure messages.
Fixtures, Plugins, and Extensibility
Extend your runner with injected resources, plugins, and deterministic lifecycle hooks.
Framework Architecture and Ownership
Layer a framework cleanly, version it as a package, and define contribution guidelines.
Phase 16: Capstone Automation Framework
Assemble, integrate, report on, and defend a complete production-grade automation framework.
Designing the Capstone Framework
Assemble UI, API, and data layers with config, fixtures, docs, and version control.
Wiring the Capstone into CI
Run the framework on pull requests and nightly schedules with enforced quality gates.
Reporting for Stakeholders
Publish shared dashboards and tailor quality summaries for engineers and leadership.
Maintenance, Review, and Demo
Establish upkeep routines, retire obsolete tests, run retrospectives, and demo results.