Let me start with something uncomfortable.
If you're a QA engineer reading this in 2025, you already feel it. Something has shifted.
The job you trained for is not the job that will exist in three years. That's not a scare tactic — it's just arithmetic. Every company you'd want to work for is now shipping AI features. Chatbots. Copilots. Summarizers. Document assistants. RAG systems answering questions from company knowledge bases. And here's the part nobody prepared you for:
Nobody knows how to test them.
Not because testers aren't smart. Because the entire discipline of testing rests on one silent assumption that AI simply breaks: the same input produces the same output. Every assertion you've ever written depends on it. Click login, land on dashboard. Every time. That assumption is the ground the whole profession stands on.
Ask an LLM the same question twice and you get two different answers. Both correct. Worded differently. There is no expected value to assert against. Your most trusted tool — assert actual == expected — is suddenly useless.
Meanwhile, on the other side of the same shift, AI is becoming the thing that writes your tests. Generate a page object in ten seconds. Repair a broken locator. Have an agent explore your app and author a suite. The engineers who use these tools well are moving three times faster than the ones who don't. And the engineers who use them badly are quietly filling their suites with confident, plausible, completely wrong tests that pass and protect nothing.
So here's where the profession actually stands:
- Testing with AI is becoming table stakes.
- Testing *AI itself* is becoming one of the scarcest, highest-paid skills in software.
- And almost nobody can do both.
That gap — that's the whole reason I wrote this series.
Why 24 books, and not a course
I'll be honest about my reasoning.
I looked at what already existed. Playwright tutorials that get you to "hello world" and stop. Python courses that spend forty hours on data science you'll never use. Blog posts about AI testing that are 90% hype and 10% "and that's why evals are important" without ever telling you what an eval is.
What didn't exist was a path. A single, continuous, deliberately-ordered journey that starts with a person who has never written a Python function and ends with someone who can architect a test framework, run it sharded across CI machines in Docker, use AI agents to author tests responsibly, evaluate a RAG system's groundedness, catch hallucinations per-claim, and then walk into an interview and prove all of it.
That's a lot of ground. It doesn't fit in one book. It fits in twenty-four — where each one goes deep on one thing, and every one builds on the last.
So that's what I built. 24 volumes. ~870 pages. Seven tiers. One continuous story.
Not 24 random ebooks stapled together. A curriculum. Volume 10 assumes Volume 2. Volume 19 references Volume 16. Volume 22 pulls threads from all of them. Volume 24 distills everything into a reference you'll keep open for years.
Let me walk you through all of it — properly. This is going to be long, because you deserve to know exactly what you'd be getting.
24 volumes. From your first line of Python to testing production AI systems.
👉 Get the complete 24-volume Master Bundle:
🎟️ Use coupon code SPECIAL70 for 70% off — or just use this link and it applies automatically:
→ Claim 70% off
🐍 TIER 1 — Python Foundations
The exact Python that test automation is built on. Nothing else.
Volume 1 — Python for Test Automation: Fundamentals to Advanced
Here's my problem with every "Python for beginners" course: they teach you Python for everything, which means they teach you Python for nothing in particular. Forty hours in, you can plot a matplotlib chart but you still don't know how to structure test data.
This volume teaches only the Python that testers actually use — but it teaches it properly. Variables, data structures, functions, control flow, error handling, file I/O — every single concept demonstrated through a real automation scenario. When you learn dictionaries, you learn them as test data. When you learn exception handling, you learn why swallowing errors in tests is a sin.
By the end you're not "someone who knows a bit of Python." You're someone ready to write real automation tomorrow.
Volume 2 — Modern Python for Automation: OOP, Async & Type Hints
This is where scripts become engineering.
The gap between a tester who writes scripts and an automation engineer who builds frameworks is exactly this volume: object-oriented programming (which is what the Page Object Model actually is), async programming (concurrency without the usual confusion), and type hints (self-documenting, bug-resistant code that seniors respect).
Most testers skip this and then wonder why their framework becomes unmaintainable at 200 tests. Don't skip it. This is the Python that Tier 4 is built on.
🎭 TIER 2 — Playwright Core
The framework that's replacing Selenium — mastered, not skimmed.
Volume 3 — Playwright with Python: Complete Getting Started Guide
Selenium had its decade. Playwright is what modern teams switch to — built-in auto-waiting that kills flakiness, one API across Chromium/Firefox/WebKit, blazing speed, and the best debugging tooling in the industry.
This is the complete on-ramp: install, configure, understand the crucial browser → context → page model (the thing that makes everything else click), write real end-to-end tests, and master codegen and the trace viewer. If you're migrating from Selenium, you'll see exactly why it's faster and less flaky — not as marketing, as mechanism.
Volume 4 — Playwright Locators & Selectors Masterclass
Ask any senior automation engineer what breaks tests. One word: locators.
Most testers write brittle ones — long XPaths, dynamic IDs, fragile CSS — that shatter the moment a developer touches the UI. Then they spend every Tuesday fixing them. This masterclass is the cure.
You'll master user-facing locators (get_by_role, get_by_label, get_by_text), locator strictness, filtering, chaining, fallback chains with or_(), and the accessibility-tree thinking that makes locators both robust and an accessibility check. This single volume earns its place the first time a UI refactor doesn't break your suite.
Volume 5 — Playwright Actions, Assertions & Auto-Waiting
The secret to non-flaky tests isn't luck. It's understanding three things deeply: how actions work, what actionability means, and why web-first assertions change everything.
You'll never write time.sleep() again — and more importantly, you'll understand why it's an anti-pattern rather than just being told. Every interaction covered: clicks, forms, uploads, dropdowns, dialogs, keyboard, mouse. Every assertion. And the actionability model that means your tests never race the browser again.
Volume 6 — Handling Complex UI: iframes, Shadow DOM & Dialogs
Basic tutorials test basic pages. Real apps are full of payment iframes, custom web components using shadow DOM, JavaScript dialogs, file downloads, drag-and-drop, and multiple tabs. This is where amateur suites fall apart and where testers say "that's not testable."
This volume gives you a proven technique for every single one. When your team says something can't be automated, you'll quietly prove them wrong.
🔬 TIER 3 — Playwright Advanced
Beyond the UI — where suites get fast, stable, and smart.
Volume 7 — API Testing & Network Interception with Playwright
This is the volume that changes how you think about test architecture.
The best suites don't push everything through the slow, flaky UI. They test smart, across layers. You'll test backend APIs directly (faster, more stable), and — this is the superpower — intercept, mock, and modify network requests. Want to test how your app handles a 500 error? A timeout? A rate-limited API? Deterministically, on demand, every time?
page.route() is the technique that impresses interviewers and rescues real projects. It also becomes essential later, in Volume 21, when you're mocking AI APIs.
Volume 8 — Visual Regression & Screenshot Testing
Your suite can be 100% green while your UI looks completely broken. Functional tests check behavior, not appearance.
You'll master screenshot comparison, baselines, and release gating on a pixel-perfect UI — and critically, you'll learn to tame visual flakiness: masking dynamic content, disabling animations, stabilizing rendering in containers, sensible thresholds. Most people try visual testing once, get drowned in false positives, and quit. This volume is why you won't.
Volume 9 — Authentication & Session Management
Logging in before every test is slow, wasteful, and the unmistakable mark of a beginner.
You'll master storage_state — log in once, save the session, reuse it across the entire suite. Handle tokens, multi-user scenarios, session isolation. And keep credentials out of your code and out of git, which is both security hygiene and something interviewers specifically probe.
This is one of those skills that instantly signals experience. It also cuts minutes off every run.
🏗️ TIER 4 — Framework Engineering
Where testers become engineers. This is the promotion tier.
Volume 10 — Building a Playwright Test Framework with Page Object Model
Anyone can write a test. Building a framework a whole team relies on — that's engineering, and it's what gets you promoted.
The Page Object Model is the foundational design pattern of professional automation: encapsulate each page's locators and actions in clean classes, keep assertions in tests, centralize everything so a UI change is a one-line fix instead of a hundred broken tests.
At 53 pages, this is the longest volume in the series, and deliberately so. If you're targeting a mid-to-senior automation role, this is the single most important volume in the bundle. The gap between "I can use Playwright" and "I can architect a maintainable framework" is exactly this — and employers pay for the second one.
Volume 11 — pytest + Playwright: Complete Framework Guide
Playwright drives the browser. pytest runs the show.
Fixtures (reusable, scoped setup — the secret to clean, DRY tests), parametrization, markers for tiered runs, conftest.py, and the plugin ecosystem (xdist, reporting, retries). Combined with Volume 10, this gives you a complete production-grade framework blueprint — the exact patterns senior engineers use and interviewers expect you to know cold.
Volume 12 — Data-Driven Testing & Configuration Management
Copy-pasting a test twenty times for twenty inputs is a beginner move. Driving one clean test with twenty data sets is engineering.
Parametrizing over datasets, loading from JSON/CSV, generating unique data so parallel runs never collide, and managing config so the same suite runs against dev, staging, or prod by changing configuration — never code. Plus keeping secrets safely out of your repository.
These are the scalability and safety skills that turn a fragile suite into a professional system.
⚙️ TIER 5 — Scale, CI/CD & Reporting
The operational tier. Rarer than test-writing. More senior. More valuable.
Volume 13 — Parallel Execution, Sharding & Docker
A suite that takes an hour to run is a suite people stop running.
Parallel execution with pytest-xdist. Sharding across CI machines. Dockerized runs using the official Playwright container — including the --ipc=host flag that stops the mysterious Chromium crashes that have cost teams entire days. Hour-long serial runs become minutes of fast feedback.
Many testers can write tests. Far fewer can operate them at scale. That gap is where senior roles live.
Volume 14 — CI/CD for Playwright: GitHub Actions, Jenkins, GitLab & Azure
Tests that only run when someone remembers to run them protect nothing.
All four major platforms in one volume — because the concepts transfer, and you'll be pipeline-fluent no matter what stack your next employer uses. Tiered triggers (fast smoke on every change, full suite nightly). Matrix builds for cross-browser coverage. Secret management. Deployment gates. And always-on artifact capture — the if: always() detail that means a failing test still uploads the trace you need to debug it.
CI/CD is what turns a test suite into a quality gate.
Volume 15 — Debugging & Reporting: Trace Viewer, Allure & HTML Reports
The difference between a junior and senior tester is often just this: how fast they diagnose a failure.
You'll master the Trace Viewer — a complete replay of every run (actions, DOM snapshots, console, network) that lets you diagnose CI-only failures without ever reproducing them locally. That capability alone is worth the volume. Plus the Inspector for live debugging, console error capture, and a systematic evidence-first process that beats guess-and-check.
Then Allure dashboards with trends and history, HTML reports, JUnit output — turning your suite from a black box into a transparent, trusted system.
👉 Everything above — and everything below — is in the Master Bundle:
https://himanshuai.gumroad.com/l/Playwright-Python-AIPro-The-Complete-24-Volume-Master-Bundle
🎟️ Coupon SPECIAL70 — 70% off. → Auto-apply link
🤖 TIER 6A — AI-Assisted Testing
Where you start pulling ahead of the field.
Everything up to here makes you an excellent modern test engineer. Everything from here makes you rare.
Volume 16 — AI-Assisted Test Automation with LLMs
AI can genuinely make you 10x faster at testing. It can also quietly poison your suite. Both are true, and which one happens depends entirely on one skill: verification.
You'll learn to generate test cases and Playwright code, write page objects, refactor, and surface missing coverage with LLMs. But the heart of this volume is the discipline: why AI hallucinates (inventing locators that don't exist, assertions that test nothing), how grounding in real context prevents it, and how to verify every output — including the critical "make it fail" check that proves a generated test actually catches bugs.
Because here's the most dangerous artifact in modern testing: a test that passes but tests nothing. It hides in a green suite and gives false confidence forever.
The golden rule of this volume: AI accelerates a skilled engineer. It doesn't replace one. Which means — paradoxically — using AI safely requires stronger fundamentals, because you're now the verifier.
Volume 17 — Self-Healing Test Automation & Smart Locators
The dream: tests that repair themselves. The nightmare: self-healing that quietly hides real bugs.
You'll build resilience hierarchies, deterministic fallback chains with or_(), element fingerprinting, similarity scoring, and AI-powered healing with a NO_MATCH safeguard. And running through all of it, the rule that keeps it honest: a heal must never hide a bug. Conservative thresholds, loud recording of every heal, human approval before permanent changes.
Few testers understand this. Even fewer implement it safely. It's a genuine differentiator and a real productivity multiplier.
Volume 18 — AI Agents for Testing: Playwright MCP & Autonomous Automation
This is the frontier.
AI agents — an LLM with tools and a goal-seeking loop — can explore your application and author tests. The Model Context Protocol (MCP) and the Playwright MCP server give an agent real browser control, grounded in the accessibility tree rather than guessing from screenshots.
But the principle that makes this trustworthy instead of chaotic: author with agents, run deterministic artifacts. Use agents to generate reviewed, deterministic tests. Never let an agent be your running suite — you'd lose determinism, speed, cost control, and reviewability all at once.
Plus the guardrails: isolation, synthetic data, scope limits, human checkpoints — designed assuming the agent will eventually surprise you, so the surprise is harmless.
Read this and you'll be the most advanced tester in almost any room you walk into.
🧠 TIER 6B — Testing AI Applications
The scarcest skill in software quality right now. Demand massively exceeds supply.
Volume 19 — Testing AI & LLM Applications: Fundamentals
Here the relationship flips. Until now, AI was your tool. Now the software under test is AI.
This volume builds the new foundation: non-determinism (and why temperature zero doesn't save you), the oracle problem (no single correct answer exists), the shift from correctness to quality, the statistical mindset (one run is a sample, not a verdict), and the move from assertions to evaluations — property-based, reference-based, LLM-as-judge, human eval, layered together.
Then the AI-specific behaviors: hallucination testing, safety and guardrails, prompt injection robustness. And the reassuring truth — an AI app is a deterministic wrapper around a non-deterministic core, so Playwright still tests most of it exactly as you've learned. The new skill layers on top, applied only where the AI actually lives.
The governing shift of this entire tier: stop asking "is the output exactly X?" and start asking "is it good enough?"
Volume 20 — Advanced LLM Testing: RAG, Evals & Hallucination Detection
At 49 pages, this is the most valuable volume in the series, and I'll defend that.
Most serious AI products aren't bare chatbots — they're RAG systems that retrieve from a knowledge base and generate a grounded answer. And their gravest failure is hallucination: confidently stating something the source never said.
You'll build rigorous eval systems (golden datasets, calibrated LLM judges, pairwise evaluation, eval-driven development — TDD for AI). You'll master RAG testing by decomposing it into two failure surfaces — retrieval and generation — and measuring each: recall and precision for retrieval, groundedness for generation, and the RAG triad to localize any failure instantly. And you'll master hallucination detection properly: per-claim groundedness, NLI entailment checking, self-consistency sampling, citation verification, and the brutally revealing unanswerable-question test — ask something the knowledge base can't answer and see whether the system admits it or invents a confident lie.
The theme: decompose, measure each surface, prove grounding.
This is what testing production AI actually looks like. Very few people can do it.
Volume 21 — AI Model & API Testing: Performance, Cost & Safety
A brilliant AI answer delivered ten seconds late is a bad product. A perfectly grounded response that costs a fortune per query bankrupts the company. Quality isn't enough.
This is the operational layer — LLMOps testing. Performance (time-to-first-token, streaming, throughput — AI latency is seconds-scale and grows with output length). Cost (token economics, usage assertions, cost-regression tests, and budget guardrails against the runaway-bill incident that terrifies every AI team). Reliability (rate limits and 429s, exponential backoff, fallbacks, graceful degradation when the AI is simply down). Safety and data handling at the API layer, plus model drift.
And a beautiful full-circle moment: you mock AI APIs using Playwright's network interception from Volume 7 — fast, free, deterministic AI tests. Fourteen volumes later, that skill pays off again.
A production-ready AI app must be good, fast, affordable, reliable, and safe. Volumes 19–20 cover "good." This covers the other four.
🎯 TIER 7 — Career & Real Projects
Because knowing it and getting paid for it are two different problems.
Volume 22 — Real-World Playwright Projects: 5 End-to-End Builds
You can know everything and still not get hired — because nobody can see inside your head. They hire what you can show them.
Five complete, portfolio-ready projects, each one a system employers instantly recognize:
- E-commerce test suite — Page Object Model framework, search/cart/checkout, data-driven with negative cases, CI-integrated.
- SaaS dashboard suite — authentication with session reuse, direct API testing, network interception for error states, visual regression.
- CI/CD at scale — parallel, sharded, Dockerized, Allure-reported pipeline.
- AI-assisted workflow — grounded generation with documented verification and deterministic output.
- AI application test strategy — three layers: Playwright wrapper, AI-core evaluation, operational testing.
Together they prove you can test conventional software, at scale, with AI, and AI itself — the complete modern range.
And crucially: how to present them so a reviewer grasps the value in ninety seconds. A brilliant project nobody can decode is a wasted project.
The career principle: employers hire demonstrated skill, not claimed knowledge.
Volume 23 — QA Automation Interview Guide: 200+ Questions & Answers
258 real questions with strong answers across 19 topic areas.
Python. Playwright fundamentals. Locators. Actions and waiting. Framework and POM design. pytest and fixtures. Data-driven testing. API and network. Advanced UI, visual, auth. Parallelism and Docker. CI/CD. Debugging and reporting. QA theory and fundamentals. Behavioral and situational with the STAR method.
And your decisive edge: the AI-testing questions almost no other candidate can answer. AI-assisted testing. Self-healing. Agents. Testing AI apps. RAG. Evals. AI operations.
When the interviewer asks how you'd test their new AI feature — and they will — you'll be the one person in their pipeline who answers fluently.
Volume 24 — Playwright Best Practices, Anti-Patterns & Cheat Sheets (The Finale)
The reference you keep open on a second monitor for years.
Best practices organized by domain. Anti-patterns as instant avoid/instead pairs. Copy-ready cheat sheets for locators, actions, assertions, pytest, CLI, CI/CD, Docker, network, auth, and AI testing. And The 20 Golden Rules that capture the entire series in a single page.
Because principles outlast tools. Playwright will evolve. New models will arrive. But locate by meaning, wait for real conditions, isolate your tests, prove they can fail, verify what AI gives you, evaluate quality where you can't assert correctness, diagnose from evidence — that thinking stays valuable no matter what changes around it.
So what do you actually walk away with?
Let me be concrete. After working through this, you can:
- Write clean, professional Python built for automation
- Build Playwright suites that don't flake, because you understand why they flake
- Write locators that survive UI refactors instead of shattering
- Test APIs directly and mock any network condition on demand
- Catch visual regressions without drowning in false positives
- Architect a Page Object Model framework a whole team can rely on
- Drive hundreds of scenarios from data, across any environment, with secrets safe
- Run an hour-long suite in minutes — parallel, sharded, containerized
- Build CI/CD pipelines on GitHub Actions, GitLab, Jenkins, or Azure
- Diagnose a CI-only failure in two minutes with the Trace Viewer
- Use AI to move 10x faster — and verify everything it hands you
- Build self-healing locators that never hide a real bug
- Direct AI agents to author tests via Playwright MCP, safely
- Test AI applications: evaluations, LLM-as-judge, hallucination, safety, prompt injection
- Test RAG systems across both failure surfaces and prove groundedness per claim
- Keep AI features fast, affordable, and resilient under rate limits and outages
- Show five portfolio projects that prove all of it
- Answer 258 interview questions — including the ones nobody else can
That's not a course outline. That's a career.
Who this is honestly for
Manual QA engineers moving into automation. Start at Volume 1. Follow the path. Don't skip. In a few months you'll be somewhere it takes most people years to reach — because you won't waste time guessing what to learn next.
Developers moving into testing or SDET roles. Skim Tier 1, then go hard from Tier 2. Tiers 4–5 will make you immediately valuable; Tier 6 will make you rare.
Working automation engineers. You'll find things you already know — and Tiers 6A and 6B are where you'll pull ahead of your entire peer group while they're still arguing about Selenium.
Bootcamp grads with no portfolio. Volume 22 is your unlock. Five projects that prove skill beats any certificate.
Anyone who has quietly wondered if AI is coming for their testing job. It's coming for the job description, not for you — if you learn the two things in Tiers 6A and 6B. That's the whole point.
Who this is NOT for
I'd rather you not buy than be disappointed.
- If you want a video course. These are books. Deep, formatted, dense books. If you learn by watching, this may frustrate you.
- If you want a shortcut. 870 pages is a commitment. There's no magic here, just a well-lit path. You still have to walk it.
- If you only want a certificate to put on LinkedIn. These teach skill. They don't issue badges. Volume 22 exists because demonstrated work beats any badge — but you have to do the work.
- If you're already an AI-testing expert. You'd get some value from Tiers 4–5 and the reference, but you're past the core value.
What actually makes this different
I'll skip the marketing language. Three things:
1. It's a path, not a pile. Volume 10 assumes Volume 2. Volume 21 pays off a skill from Volume 7. Volume 22 assembles all of it. Every volume knows what the others taught. That's what makes it click instead of just accumulating.
2. It goes where nothing else goes. Six volumes on AI — both using it and testing it. Grounding, hallucination, MCP agents, evals, LLM-as-judge, RAG triads, groundedness detection, token economics. Not hype. Actual technique, with actual code.
3. It's honest about AI. I don't tell you AI will write all your tests. I tell you it will hallucinate locators, produce tests that pass and check nothing, and that your job is to verify. That's less exciting and considerably more useful.
🎟️ Coupon: SPECIAL70 — 70% off
I want these books read, not admired from a distance. So I'm putting a 70% off coupon on the complete Master Bundle for everyone reading this.
Code: SPECIAL70
Apply it at checkout — or just use this link and it applies itself:
→ Get the Master Bundle with 70% off
Think about what's on the other side of actually working through this. One raise. One role change. One interview where you're the only candidate who can explain how to test a RAG system's groundedness. One week where the Trace Viewer saves you eight hours of debugging. Any single one of those makes this trivially worth it.
💬 And if it's still too much — please just message me
I mean this genuinely, and I'm going to say it plainly.
I know exactly who reads posts like this. Some of you are students. Some of you are between jobs. Some of you are in places where even a discounted price is a real, serious number. Some of you are the exact people who'd get the most out of these books and are the least able to buy them.
I don't want money to be the reason you don't learn this.
So: if it still feels like too much for your situation, just DM me directly on LinkedIn. No form, no justification essay, no proof required. Tell me where you are and what you're trying to do, and I'll sort you out with something that works for you. I'll make you the best offer I possibly can.
I'd genuinely rather these end up in the hands of someone who'll build something with them.
That offer is real. Please use it if you need it.
One last thing
I've been in this field long enough to have watched a few "this changes everything" moments come and go. Most didn't.
This one is different. Not because AI writes code — that's the small part. Because AI has created an entire new category of software that has to be tested and that nobody knows how to test. Every company shipping an AI feature has this problem right now, today, and they are looking for people who can solve it.
That's not a threat to your career. That's the biggest opportunity your career has ever had — if you're on the right side of it.
The engineers who come out of this shift ahead won't be the ones who were most worried. They'll be the ones who learned both halves: how to test with AI, and how to test AI.
That's what these 24 volumes are. That's the entire point.
I hope you'll build something good with them.
— Himanshu
👉 Get the complete 24-volume Master Bundle:
https://himanshuai.gumroad.com/l/Playwright-Python-AIPro-The-Complete-24-Volume-Master-Bundle
🎟️ Coupon SPECIAL70 — 70% off. → Auto-apply link
💬 Still too much for your situation? DM me on LinkedIn — I'll make you the best offer I can. Seriously.
📚 The complete 24-volume list
🐍 Tier 1 — Python Foundations
- Python for Test Automation — Fundamentals to Advanced
- Modern Python for Automation — OOP, Async & Type Hints
🎭 Tier 2 — Playwright Core
- Playwright with Python — Complete Getting Started Guide
- Playwright Locators & Selectors Masterclass
- Playwright Actions, Assertions & Auto-Waiting
- Handling Complex UI in Playwright — iframes, Shadow DOM & Dialogs
🔬 Tier 3 — Playwright Advanced
- API Testing & Network Interception with Playwright
- Visual Regression & Screenshot Testing in Playwright
- Authentication & Session Management in Playwright
🏗️ Tier 4 — Framework Engineering
- Building a Playwright Test Framework with Page Object Model
- pytest + Playwright — Complete Framework Guide
- Data-Driven Testing & Configuration Management
⚙️ Tier 5 — Scale, CI/CD & Reporting
- Parallel Execution, Sharding & Docker for Playwright
- CI/CD for Playwright — GitHub Actions, Jenkins, GitLab & Azure
- Debugging & Reporting — Trace Viewer, Allure & HTML Reports
🤖 Tier 6A — AI-Assisted Testing
- AI-Assisted Test Automation with LLMs
- Self-Healing Test Automation & Smart Locators
- AI Agents for Testing — Playwright MCP & Autonomous Automation
🧠 Tier 6B — Testing AI Apps
- Testing AI & LLM Applications — Fundamentals
- Advanced LLM Testing — RAG, Evals & Hallucination Detection
- AI Model & API Testing — Performance, Cost & Safety
🎯 Tier 7 — Career & Real Projects
- Real-World Playwright Projects — 5 End-to-End Builds
- QA Automation Interview Guide — 200+ Questions & Answers
- Playwright Best Practices, Anti-Patterns & Cheat Sheets
Connect with me: LinkedIn · Substack — free daily articles · 1:1 consulting · himanshuai.com
If this was useful, a repost helps it reach someone who needs it. 🙏
Top comments (0)