Course · 43 lessons

Software Testing Roadmap.

A software testing course: the test pyramid and test doubles, pytest, browser automation with Selenium and Playwright, API and contract testing, and flaky CI.

This path builds testing skill in layers: strategy (what to test, and with what kind of test double), a shared pytest foundation, then three specialized tracks — browser automation, API/contract testing — and finally diagnosing flakiness at scale.

Beginner — foundations

Strategy: the test pyramid and where each test type earns its cost.
Pytest: your first test, fixtures, parametrization, markers, and project layout — the runner every other track here assumes you already know.
Selenium: locators, waits, element interaction, and browser chrome (windows/frames/alerts) — the framework behind most existing browser-test suites.
Playwright: the same ground — locators, auto-waiting, actions, fixtures — on the newer framework most teams reach for on a fresh project. Both are included in full; pick one to build fluency in first, and treat the other as a fast second pass once the concepts click, since locators/waits/page-objects transfer almost directly between them.
API testing: requests + pytest against a REST API, from your first test through building a local test API to validate against with no external dependencies.

Intermediate — production patterns

Strategy: choosing the right test double (mock, stub, fake) at each dependency boundary.
Pytest: monkeypatching, capturing files/output/logs, and measuring coverage honestly.
Selenium: the Page Object Model, running Selenium suites through pytest, and diagnosing flaky UI tests (staleness, retries, CI-specific failures).
Playwright: authentication/session reuse, network interception and API mocking, and debugging with traces, UI Mode, and codegen.
API testing: auth (bearer tokens, 401 vs 403), mocking HTTP calls, and timeouts/retries against endpoints that fail on purpose.

Advanced — scale and reliability

Strategy: a full flaky-test diagnosis and stabilization pass — the payoff lesson for everything above it.
Pytest: writing your own plugins/hooks, and keeping large suites fast and deterministic.
Selenium: Selenium Grid/remote WebDriver, and modern CDP/BiDi-based automation.
Playwright: parallelism, sharding, and configuration at scale; visual comparison and API testing from inside the same framework.
API testing: pagination/rate-limit testing, and contract testing against an OpenAPI spec in CI.

The roadmap, step by step

testing Step 1 of 43

Testing Strategy & Test Pyramid (Beginner)

Choose between unit, integration and end-to-end tests by speed and reliability, with Jest examples of a pure unit test and an injected, fixed clock.

pytest Step 2 of 43

Your First Pytest Test

Write a test, run it, and read pytest's output — including the assertion introspection that makes a failure tell you what actually went wrong.

pytest Step 3 of 43

Pytest Fixtures

Replace repeated setup with fixtures, control how often they run with scope, and watch teardown happen after a test fails.

pytest Step 4 of 43

Parametrized Tests in Pytest

Run one test function against many inputs with parametrize, name the cases so failures stay readable, and parametrize a fixture to rerun a whole file.

pytest Step 5 of 43

Pytest Markers, Skipping, and xfail

Tag tests with custom markers, select them with -m, skip conditionally, and record a known bug as xfail so it fails the build the day it is fixed.

pytest Step 6 of 43

Test Layout and Pytest Configuration

Fix the ModuleNotFoundError every new pytest project hits, understand rootdir and conftest, and put defaults in pyproject.toml, not your shell.

selenium Step 7 of 43

Your First Selenium Test

Install Selenium 4, drive a real browser, and read the three exceptions you'll meet in your first hour, plus the lifecycle that stops leaks.

selenium Step 8 of 43

Locators: Finding Elements Reliably

The eight By strategies, when XPath earns its keep over CSS, Selenium 4's relative locators, and why a generated id makes a test that breaks next deploy.

selenium Step 9 of 43

Waits: Implicit, Explicit, and Why sleep Fails

Selenium does not wait for anything. Replace sleeps with WebDriverWait and expected conditions — and never mix implicit and explicit waits.

selenium Step 10 of 43

Interacting with Elements and Forms

Type, click, select and upload — plus ActionChains for hover and drag, and what to do when a cookie banner intercepts your click.

selenium Step 11 of 43

Windows, Frames, and Alerts

Three contexts a locator cannot cross — new tabs, iframes and native dialogs — and the switch_to calls that move between them without losing your place.

playwright Step 12 of 43

Your First Playwright Test

Install Playwright, write an end-to-end test against a real page, and read the runner's output — including what a failing assertion actually tells you.

playwright Step 13 of 43

Locators: Finding Elements That Stay Found

Role, label and text locators, why strict mode fails on purpose, and how filtering and chaining pin down one element in a list without using nth().

playwright Step 14 of 43

Auto-Waiting and Web-First Assertions

Why expect(locator) retries and expect(value) does not, what actionability checks block on, and how to fix a flaky test without adding a sleep.

playwright Step 15 of 43

Actions and Forms

Fill inputs, tick boxes, choose options, upload files and handle dialogs — plus what fill actually dispatches and when you need pressSequentially instead.

playwright Step 16 of 43

Hooks, Fixtures, and Test Isolation

Group tests with describe, share setup with beforeEach, then replace both with custom fixtures that build a page object and clean up after themselves.

api-testing Step 17 of 43

Testing a REST API with requests and pytest

Write your first automated API test in Python — a GET request, an assertion on the JSON body, and a failure that shows exactly what pytest caught.

api-testing Step 18 of 43

HTTP Methods and Body Encodings

Test PUT, PATCH, and DELETE against a real API, then chase down the bug that happens when a JSON API receives a form-encoded body instead.

api-testing Step 19 of 43

Fixtures, Sessions, and Parametrize for API Tests

Stop repeating BASE_URL and header setup in every test — share a requests.Session through a pytest fixture, parametrize across cases, and read the ScopeMismatch error that follows.

api-testing Step 20 of 43

Validating JSON Responses and Contracts

Why comparing a whole response body with == breaks on the first dynamic field, and how jsonschema catches a missing or mistyped field that a value check would miss.

api-testing Step 21 of 43

Building a Local Test API with the Standard Library

Every remaining lesson in this track needs an API you fully control — build one in under 40 lines with http.server, no framework and no third-party dependency, and give each test a fresh, isolated instance.

testing Step 22 of 43

Test Doubles & Dependency Boundaries (Intermediate)

When to use a stub, a fake or a mock, shown with Jest tests against a repository interface, plus how an over-specified mock breaks on a random id.

pytest Step 23 of 43

Monkeypatching and Mocking in Pytest

Replace network calls, clocks and environment variables in a test with monkeypatch and unittest.mock, and why patching the wrong name fails silently.

pytest Step 24 of 43

Testing Files, Output, and Logs with Pytest

Use tmp_path for real files that clean themselves up, capsys to assert on printed output, and caplog to test the log lines your code emits.

pytest Step 25 of 43

Measuring Coverage with pytest-cov

Run coverage from pytest, read the missing-lines report, turn on branch coverage, and see why a suite at 100% can still miss the bug.

selenium Step 26 of 43

The Page Object Model

Move locators out of tests and into objects that model behaviour — component objects, page-returning navigation, and mistakes that make a POM worse.

selenium Step 27 of 43

Running Selenium Suites with pytest

Fixtures that pick a browser from the command line, parametrised cross-browser runs, parallel execution with xdist, and JUnit XML for CI.

selenium Step 28 of 43

Flaky Tests: Staleness, Retries, and CI

Fix StaleElementReferenceException properly, find the five causes of tests that only fail in CI, and use retries as a signal rather than a cure.

playwright Step 29 of 43

Authentication and Reusing Session State

Log in once instead of once per test: storage state files, a setup project with dependencies, and per-worker accounts when tests mutate the logged-in user.

playwright Step 30 of 43

Network Interception and API Mocking

Intercept requests with page.route to mock JSON, force error states, delay responses, and patch a real reply — then record a HAR to replay it.

playwright Step 31 of 43

Debugging: Traces, UI Mode, and Codegen

Turn a red CI run into an answer: record traces, open them in the viewer, step through with the inspector, and generate a test with codegen.

api-testing Step 32 of 43

Testing Bearer Tokens, Basic Auth, and 401 vs 403

Extend the local test API with two auth schemes and catch the assumption that 'wrong token' and 'no token' return the same status code — they don't, and mixing them up hides real bugs.

api-testing Step 33 of 43

Mocking HTTP Calls with responses

Test the client code that calls an API without a real server anywhere — and hit the error responses throws when a test forgets to register the exact call it makes.

api-testing Step 34 of 43

Timeouts and Retries Against a Flaky Endpoint

Extend the local test API with a slow route and one that fails a fixed number of times, then measure the difference between a single request, a retrying session, and one with too few retries configured.

testing Step 35 of 43

Flaky Tests Diagnosis & Stabilization (Advanced)

Measure a flaky Jest test over repeated runs, then fix it with seeded randomness, fake timers, awaiting completion and isolated state, not sleeps.

pytest Step 36 of 43

Pytest Plugins and Hooks

Add your own command-line flags, modify collection, react to test results, and package the whole thing as an installable pytest plugin.

pytest Step 37 of 43

Fast, Deterministic Pytest Suites

Find the slow tests with --durations, run them in parallel with xdist, expose order dependence with random ordering, and wire the suite into CI properly.

selenium Step 38 of 43

Selenium Grid and Remote WebDriver

Run the same suite against browsers on other machines — standalone and hub-node Grid in Docker, session capabilities, video recording, and sizing the pool.

selenium Step 39 of 43

CDP, BiDi, and Modern Selenium

Intercept network traffic, emulate devices and capture console errors — with Chrome DevTools Protocol and WebDriver BiDi as its replacement.

playwright Step 40 of 43

Parallelism, Sharding, and Configuration

Control how many workers run, when to force serial execution, how to shard a suite across CI machines, and what a retry is really telling you.

playwright Step 41 of 43

Visual Comparison and API Testing

Pixel and ARIA snapshots that do not fail on every deploy, plus using the request fixture to seed data over HTTP and test an API without a browser.

api-testing Step 42 of 43

Testing Pagination and Rate Limits

The most common pagination bug isn't a broken API — it's a test that hardcodes the number of pages. Then: testing a 429 response and honoring Retry-After.

api-testing Step 43 of 43

Contract Testing with OpenAPI, and Running in CI

Turn an OpenAPI document into the same jsonschema validation from earlier in this track, catch a proposed API change that breaks the contract, and wire the suite into GitHub Actions with a JUnit report.