Modern QA

Module 1: Introduction to Modern QA

Quality assurance in 2026 looks very different from the manual-click-through era, and even from the pure Selenium automation era that followed it. Teams ship many times a day, pipelines gate every merge, and AI assistants now draft tests, triage failures, and even heal broken selectors. This opening module gives you the map before the journey: what modern QA actually means, where it happens in the delivery lifecycle, how manual, automated, and AI-assisted testing fit together, and why this course builds on Playwright, TypeScript, and CI/CD. By the end you will understand the shape of the whole discipline and the exact roadmap the remaining modules follow.

The 2026 QA landscape

For a long time, “QA” meant a separate team that received a build, worked through a spreadsheet of test cases by hand, and filed bugs before a quarterly release. That model has all but disappeared on modern product teams. Continuous delivery, cloud infrastructure, and small autonomous squads have compressed the release cycle from months to minutes. When code can reach production the same afternoon it was written, quality cannot be a gate at the end—it has to be built into every step.

The modern QA engineer is therefore less a “checker” and more a quality enabler. You still design test cases and find bugs, but you also build the automation that runs them, wire that automation into the pipeline, and increasingly supervise AI tools that generate and maintain tests. The job has moved up the value chain: from executing checks to designing the systems that execute checks for you.

Three forces define the 2026 landscape:

• Speed. Teams merge dozens of pull requests a day. Tests must be fast, reliable, and run automatically—flaky or slow suites get ignored or disabled, which is worse than having none.
• Breadth. Applications span web, mobile, APIs, and data pipelines. A single feature often touches a front end, several services, and a database, so modern QA covers end-to-end, API, and integration layers, not just the UI.
• AI augmentation. Large language models and testing agents now draft test code from a description, suggest assertions, cluster failures, and propose fixes for broken locators. They do not replace testers—they remove the repetitive parts so testers focus on judgement.

Shift-left and shift-right testing

Two phrases dominate modern quality conversations. Picture the delivery timeline as a line running left (idea, design, code) to right (release, production, real users). Traditional testing clustered in the middle-right: test after the code was done. Modern teams push testing out in both directions.

Shift-left means testing earlier—moving quality activities toward the start of the timeline. Instead of waiting for a finished feature, you test the design, write unit tests alongside the code, run static analysis on every commit, and execute fast integration checks before a pull request can merge. The principle is simple: a bug caught while the author is still looking at the code costs minutes to fix; the same bug caught in production can cost hours of incident response and lost trust.

Shift-right means testing later—extending quality activities into production itself. Real users on real devices surface issues that no staging environment can. Shift-right practices include monitoring and alerting, synthetic tests that run against production on a schedule, feature flags that expose a change to 1% of users first, and chaos experiments that deliberately break things to confirm the system recovers.

These are not competitors; they are two ends of the same strategy. Shift-left catches defects cheaply before release. Shift-right catches the defects that only appear under real-world conditions. A mature team does both.

Manual vs automation vs AI-assisted QA

These three approaches are often framed as a progression, but in practice they coexist. Each is strong at something the others are weak at.

Manual testing is a human exploring the application with intent. It is irreplaceable for exploratory testing, usability judgement, visual polish, and anything requiring human taste (“does this flow feel confusing?”). It is slow, hard to repeat identically, and does not scale to run on every commit.

Automated testing is code that drives the application and asserts on the result. It is fast, perfectly repeatable, and runs unattended in a pipeline thousands of times. Its weakness is that it only checks what you told it to check—it has no intuition and no eye for the unexpected.

AI-assisted QA is the newest layer. Here an AI model or agent helps produce and maintain the automation: generating a draft test from a plain-language description, suggesting robust locators, writing assertions, clustering a wall of failures into a few root causes, or proposing a selector fix when the UI changes. The AI accelerates the human; it does not own quality. A test an AI wrote still needs a human to confirm it checks the right thing.

The table below summarises when to reach for each.

Approach	Best for	Weak at
Manual	Exploratory testing, usability, visual judgement, one-off checks	Speed, repeatability, running on every commit
Automated	Regression, repeatable checks in CI, broad coverage at speed	Noticing the unexpected, judgement, maintenance cost
AI-assisted	Drafting tests, healing locators, triaging failures, boilerplate	Owning correctness; it still needs human review

Where Playwright, CI/CD, and AI agents fit

It helps to see the three pillars of this course as answers to three different questions.

Playwright answers “how do I reliably drive the application?” It is a modern browser-automation framework from Microsoft that controls Chromium, Firefox, and WebKit with one API. Its auto-waiting and web-first assertions remove most of the flakiness that plagued older tools, which is why it has become the default choice for new web test suites. You will spend Modules 2, 4, and 5 becoming fluent in it.

CI/CD answers “how do these tests run automatically and gate releases?” Continuous Integration runs your test suite on every push; Continuous Delivery promotes a build through environments once the tests pass. Without CI/CD, automation is just a script someone runs occasionally. With it, your tests become a true quality gate.

AI agents answer “how do I move faster without drowning in maintenance?” Modern tooling and coding assistants help you generate tests, keep locators healthy as the UI changes, and understand failures quickly. You supervise; the agent handles the repetitive scaffolding.

// A one-line taste of what Playwright code looks like.
// You will understand every part of this by the end of Module 4.
import { test, expect } from '@playwright/test';

test('homepage shows the sign-in button', async ({ page }) => {
  await page.goto('https://example.com');
  await expect(page.getByRole('button', { name: 'Sign in' })).toBeVisible();
});

Notice there is no manual “wait two seconds” anywhere. Playwright waits automatically for the button to appear before asserting—a core idea you will meet properly in Module 4.

The modern QA toolchain

A modern QA setup is a chain of tools that hand work to one another. Learning the names now means the later modules slot into a picture you already hold.

• Language and runtime: TypeScript/JavaScript running on Node.js. Playwright tests are written here (Module 3).
• Test framework: Playwright Test—runner, assertions, fixtures, reporting, all in one (Modules 2, 4, 5).
• Version control: Git, with every change arriving as a pull request that must pass checks before merge.
• CI/CD platform: GitHub Actions, GitLab CI, or similar, running the suite on every push and blocking merges on failure.
• Reporting and artifacts: HTML reports, traces, screenshots, and videos stored from each run so you can debug a failure you never saw happen.
• AI assistance: coding assistants and testing agents that draft tests, suggest locators, and triage failures across the whole chain.

Each link is only as useful as the one before it. A brilliant test that never runs in CI protects nothing; a fast pipeline running weak tests gives false confidence. This course builds the chain link by link.