30-Day AI-Augmented Automation Testing Course (Python)
30-DAY AI-AUGMENTED AUTOMATION
TESTING COURSE
Beginner to Advanced with Python, Selenium, Playwright & AI Testing Tools
Prepared by Ajaharuddin Mallick
QA & Automation Specialist · Kolkata, India
Page 1
30-Day AI-Augmented Automation Testing Course (Python)
How to Use This Course
This is the Python edition of the automation testing course, built around the stack you're
positioning for freelance work: Python, Selenium, Playwright, and PyTest — with AI-augmented
testing woven into every week rather than treated as a single add-on topic.
Each day includes a Learn section, a Practice section, a Deliverable you keep as a portfolio
artifact, and (most days) an AI Angle callout connecting that day's skill to an AI tool or technique
used in modern QA. By Day 30 you'll have a full Python-based portfolio plus direct experience
evaluating where AI genuinely helps in testing and where it doesn't.
Goal: This document doubles as your own learning tracker and your future teaching syllabus.
The Learn/Practice/Deliverable structure converts directly into lesson plans when you're ready
to teach this to others.
Daily Time Commitment
Plan for 1.5–3 hours per day. Days 7, 14, 21, and 28–29 are project-heavy — block extra time
on those.
Tools You'll Need
• Python 3.10+ and a code editor (VS Code recommended)
• pip and a virtual environment tool (venv)
• Selenium and Playwright for Python (installed in Week 1–2)
• PyTest as the test runner/framework throughout
• Git and a free GitHub account
• Free trial accounts for at least one AI-testing tool (Applitools, Testim, or Mabl) and an
OpenAI/Anthropic API key for the AI test-generation days (free tier is enough)
• A demo site to practice on (e.g. a free practice site such as [Link])
Page 2
30-Day AI-Augmented Automation Testing Course (Python)
Table of Contents
Page 3
30-Day AI-Augmented Automation Testing Course (Python)
Week 1: Python & Testing Foundations
Goal: build core Python fluency and testing concepts, with an early look at how AI fits into the
QA workflow.
Day 1 — Python Essentials I
Learn:
• Variables, data types, operators, control flow (if/else, loops)
• Functions — definitions, parameters, return values
• Lists, dictionaries, and basic comprehensions
Practice:
• Write 10 small functions manipulating lists/dictionaries (filter, transform, aggregate)
• Set up a Python virtual environment and run your first script
Deliverable: A `day1_basics.py` file with all exercises, committed to a new GitHub repo for this
course.
AI Angle: AI coding assistants (like Claude or Copilot) are now standard in professional QA
workflows. Try generating one of today's functions with an AI assistant, then compare it line-by-
line to your own — this habit of reviewing AI output critically will matter throughout the course.
Day 2 — Python Essentials II — OOP Basics
Learn:
• Classes, objects, methods, `__init__`
• Why OOP matters for test automation — this is the foundation for Page Object Model
later
Practice:
• Build a simple `Car` or `User` class with attributes and methods
• Write a small class hierarchy with inheritance
Deliverable: `day2_oop.py` with a working class and at least one subclass.
Day 3 — HTML, CSS, and the DOM
Learn:
• HTML structure and common elements (form, input, button, table)
• CSS selectors (class, id, attribute, nth-child) and XPath basics — both are used heavily
in Selenium
• What the DOM is and how browsers represent a page as a tree
Practice:
• Use browser DevTools to inspect 10 elements on a real site and write both a CSS
selector and an XPath for each
• Build a simple static HTML form to use as a practice target
Deliverable: A `practice_form.html` file you'll automate in Day 7.
Page 4
30-Day AI-Augmented Automation Testing Course (Python)
Day 4 — Automation Testing Concepts
Learn:
• Why automate: regression coverage, speed, consistency vs. manual testing
• The Test Pyramid and where UI/end-to-end automation fits
• Test types: smoke, regression, functional, end-to-end
Practice:
• Write 5 manual test cases in plain English for a real login flow you use
• Map each to a level of the test pyramid
Deliverable: A one-page test plan document.
AI Angle: AI test-case generation tools can read a requirement or user story and propose test
cases automatically. Try feeding your login flow description to an AI assistant and compare its
suggested test cases against your own list — note what it caught that you missed, and vice
versa.
Day 5 — Selenium Setup & First Test
Learn:
• Installing Selenium for Python, WebDriver basics, browser drivers
• Core methods: `[Link]()`, `find_element()`, `.click()`, `.send_keys()`
Practice:
• Install Selenium and write your first test: open a real site and assert the page title
Deliverable: Working Selenium script with one passing assertion.
Day 6 — PyTest Basics
Learn:
• Why PyTest over plain `unittest` — fixtures, simpler assertions, parametrization
• Writing test functions, `assert` statements, running with `pytest` CLI
Practice:
• Convert your Day 5 Selenium script into a proper PyTest test function
• Add 3 more assertions covering different page elements
Deliverable: `test_homepage.py` running cleanly via `pytest`.
Day 7 — Practice Project — Login Flow End-to-End
Learn:
• Review Days 1–6 before starting
Practice:
• Automate a real or demo login page with Selenium + PyTest: valid login, invalid login,
empty-field validation
• At least 4 test cases covering positive and negative scenarios
Deliverable: A complete `test_login.py` file — your first portfolio piece. Push to GitHub with a
clear README.
Page 5
30-Day AI-Augmented Automation Testing Course (Python)
Week 2: Core Selenium & PyTest Skills
Goal: move from single tests to realistic, maintainable suites, and introduce self-healing/AI
locators.
Day 8 — Locator Strategy & Self-Healing Concepts
Learn:
• Locator priority in Selenium: ID > CSS > XPath, and why brittle locators break tests
• Best practice: stable `data-testid` attributes
• Introduction to self-healing locators — how AI tools detect when an element's attributes
change and auto-adjust instead of failing
Practice:
• Add `data-testid` attributes to your Day 3 practice form
• Rewrite your Day 7 tests using these stable selectors
Deliverable: Refactored test files using stable selectors.
AI Angle: Read documentation on how one self-healing tool (Testim, Mabl, or Healenium — an
open-source option that wraps Selenium) detects locator changes. Note the trade-off:
convenience vs. the risk of a test silently passing against the wrong element.
Day 9 — Test Data Management with PyTest Fixtures
Learn:
• PyTest fixtures for setup/teardown and shared test data
• Loading test data from JSON/CSV/YAML files
Practice:
• Create a `[Link]` file with multiple test user records
• Rewrite your login tests as data-driven using `@[Link]`
Deliverable: Data-driven `test_login.py` using fixtures and parametrize.
Day 10 — Page Object Model in Python
Learn:
• Structuring a `pages/` package with one class per page (ties directly back to your Day 2
OOP practice)
• Encapsulating locators and actions inside page classes
Practice:
• Refactor your login test to use a `LoginPage` class with methods like `login(username,
password)`
Deliverable: POM-structured login test — a strong portfolio signal.
Day 11 — Forms, Dropdowns, Checkboxes, File Uploads
Learn:
• Handling `<select>` dropdowns with Selenium's `Select` class, radio groups, multi-
checkboxes
Page 6
30-Day AI-Augmented Automation Testing Course (Python)
• File upload automation via `send_keys()` to file input elements
Practice:
• Build/find a form with all these element types and automate full coverage
Deliverable: Test file covering all major form element types.
Day 12 — API Testing with Python (requests)
Learn:
• Using the `requests` library to test REST APIs directly
• Validating status codes, response JSON, and headers
Practice:
• Use a free public API and write 5 API tests covering GET/POST and error cases with
PyTest
Deliverable: `test_api.py` with 5 passing API-level tests.
Day 13 — Mocking & Test Doubles
Learn:
• Using `[Link]` / `pytest-mock` to stub external calls
• Why mocking matters for testing error states and edge cases without depending on a
real backend
Practice:
• Mock an API response in one of your tests to simulate a server error, then a slow
response
Deliverable: Test demonstrating both a mocked success and a mocked failure response.
Day 14 — Practice Project — Multi-Page Checkout Flow
Learn:
• Review fixtures, POM, and mocking from this week
Practice:
• Automate a full checkout flow on a demo e-commerce site: add to cart → cart review →
checkout form → confirmation, using POM throughout
• Mock the payment/order API call
Deliverable: Full `test_checkout.py` suite — second major portfolio piece.
Page 7
30-Day AI-Augmented Automation Testing Course (Python)
Week 3: Playwright (Python) & AI-Augmented Testing
Goal: add Playwright to your toolkit and go deep on practical AI testing techniques.
Day 15 — Playwright for Python — Setup
Learn:
• Installing `playwright` for Python, sync vs. async API
• Key advantages over Selenium: built-in auto-waiting, true cross-browser support, faster
execution
Practice:
• Install Playwright and rewrite one Day 7 login test using Playwright's sync API
Deliverable: Working Playwright project with one converted test.
Day 16 — Playwright Core API & PyTest Integration
Learn:
• Locators, actions, and assertions using `pytest-playwright`
• Why Playwright's auto-waiting reduces flaky tests compared to manual Selenium waits
Practice:
• Convert your full Day 11 form suite to Playwright + PyTest
Deliverable: Playwright test file mirroring earlier Selenium work.
Day 17 — Page Object Model with Playwright
Learn:
• Adapting your Python POM structure for Playwright's locator API
• Fixtures for page objects in `pytest-playwright`
Practice:
• Rebuild your `LoginPage` class for Playwright and use it in a fixture
Deliverable: POM-structured Playwright login test.
Day 18 — AI Test Case Generation in Practice
Learn:
• Using an LLM (via API or chat) to generate test cases from a feature description or user
story
• Prompt patterns that produce useful, specific test cases rather than generic ones
Practice:
• Write a short feature description for a real page, generate test cases with an AI
assistant, then implement the 3 best ones as actual Playwright tests
Deliverable: 3 AI-suggested test cases, implemented and passing.
Page 8
30-Day AI-Augmented Automation Testing Course (Python)
AI Angle: This is a full hands-on AI angle day. Document which AI-suggested cases were
genuinely useful vs. which needed heavy editing — this becomes a talking point in interviews
and client pitches about how you use AI responsibly rather than blindly.
Day 19 — Visual Regression & AI Visual Testing
Learn:
• Why pixel-level visual bugs slip past functional tests
• Playwright's built-in screenshot comparison, and how Applitools' AI-based visual diffing
reduces false positives from things like anti-aliasing or dynamic content
Practice:
• Add a visual regression test using Playwright's screenshot comparison
• Sign up for a free Applitools account and run the same comparison through it
Deliverable: A passing visual regression test with a baseline screenshot, plus notes comparing
the two approaches.
Day 20 — Authentication & Session Reuse
Learn:
• Saving and reusing Playwright's `storage_state` so tests skip repeated logins
• Why this matters for large suites and CI speed
Practice:
• Implement storage-state reuse so your checkout tests skip the login step
Deliverable: Configured storage-state setup reused across at least 3 tests.
Day 21 — Practice Project — Rebuild in Playwright + AI-Assisted Test Design
Learn:
• Review Days 15–20
Practice:
• Rebuild your Week 2 checkout-flow project in Playwright with POM and a shared auth
fixture
• Use an AI assistant to review your finished suite for missing edge cases, then add at
least 2 of its suggestions
Deliverable: Full Playwright + POM checkout suite, AI-reviewed — your strongest portfolio
piece yet.
Page 9
30-Day AI-Augmented Automation Testing Course (Python)
Week 4: CI/CD, AI Tooling Comparison & Capstone
Goal: package everything into a professional, freelance-ready capstone with a clear AI-
augmented QA narrative.
Day 22 — Git/GitHub Cleanup
Learn:
• If already comfortable with Git, use this day to organize and document all previous work
instead
Practice:
• Organize all course projects into a clean GitHub repo (or repos) with clear READMEs
Deliverable: Clean, organized GitHub presence for all course work so far.
Day 23 — CI/CD Integration
Learn:
• Setting up GitHub Actions to run PyTest (Selenium or Playwright) automatically on push
• Headless browser configuration for CI environments
Practice:
• Add a `.github/workflows/[Link]` file and confirm tests run automatically on push
Deliverable: A repo with a green CI badge.
Day 24 — Test Reporting
Learn:
• Generating HTML reports with `pytest-html` or Allure for Python test suites
• Why clear, shareable reports matter for clients and teams
Practice:
• Configure HTML reporting for your capstone-in-progress and generate a sample report
Deliverable: A generated HTML test report you can screenshot for your portfolio.
Day 25 — Comparing AI Testing Tools Hands-On
Learn:
• Side-by-side comparison: Testim, Mabl, and Applitools — what each is actually good at
(self-healing, low-code authoring, visual AI)
• Where AI tooling adds real value vs. where solid fundamentals (POM, good locators,
clean test data) still matter more
Practice:
• Run the same simple test scenario through a free trial of one AI tool you haven't tried
yet, and compare against your own Playwright/Selenium version
Deliverable: A written comparison (strengths/limits/cost) — this becomes content for your
freelance positioning and possibly a teaching module.
Page 10
30-Day AI-Augmented Automation Testing Course (Python)
AI Angle: This day is explicitly about building informed, marketable opinions on AI testing tools
— valuable both for freelance conversations with clients and for teaching others later.
Day 26 — Flaky Tests & Performance
Learn:
• Common causes of flaky tests: race conditions, hard-coded sleeps, shared state
• Proper waits in Selenium (`WebDriverWait`) vs. Playwright's built-in auto-waiting
Practice:
• Deliberately introduce a flaky test, diagnose the cause, then fix it properly
Deliverable: Before/after notes documenting a flaky test fix — strong interview material.
Day 27 — Best Practices for Production-Grade Suites
Learn:
• Test independence and data cleanup strategies (API-based teardown vs. UI-based)
• Environment configuration — running the same suite against dev/staging/prod
Practice:
• Add environment config support (e.g. via `.env` and `[Link]`) to your capstone project
Deliverable: Capstone project with environment-based configuration.
Day 28 — Capstone Project — Part 1
Learn:
Practice:
• Choose a real or demo e-commerce/SaaS site and build a full Python test suite: UI tests
(Playwright + POM), API tests, CI pipeline, HTML reporting
• Cover at least 3 user flows end-to-end
Deliverable: Capstone project structure and first flow fully automated.
Day 29 — Capstone Project — Part 2
Learn:
Practice:
• Complete remaining flows, finalize CI integration, confirm reporting works end-to-end
• Add a visual regression check, a mocked API scenario, and one AI-generated test case
you implemented and validated
Deliverable: Complete, polished capstone project — your flagship portfolio piece, explicitly
demonstrating AI-augmented QA practice.
Day 30 — Portfolio Packaging & Freelance Positioning
Learn:
• What clients on Upwork/Fiverr look for in a Python QA automation portfolio
Page 11
30-Day AI-Augmented Automation Testing Course (Python)
• How to position 'AI-augmented QA in Python' as a specialization — manual testing +
automation + applied AI tooling
Practice:
• Write a clear README for the capstone (problem, approach, tech stack, how to run it)
• Record a 2–3 minute screen-recording walkthrough
• Draft your Upwork/Fiverr profile summary highlighting Python, Selenium, Playwright,
PyTest, CI/CD, and AI-augmented testing
Deliverable: A complete, presentable portfolio: GitHub repo + README + demo video +
freelance profile draft.
Page 12
30-Day AI-Augmented Automation Testing Course (Python)
After Day 30: Teaching This Course
Since the plan is to learn this yourself first and teach it afterward, a few notes on that transition:
• Your own Day 1–30 projects become the example solutions/demo code for students.
• Each day's Deliverable works well as a graded assignment or checkpoint.
• The AI Angle callouts threaded through the course are a strong differentiator — most
beginner Python QA courses don't address AI tooling at all, let alone with hands-on
comparison work like Days 18 and 25.
• Consider structuring a paid version as: Week 1 free/taster, Weeks 2–4 paid — a
common structure for freelance course creators.
Tracking Your Progress
Use the table below to check off each day as you complete it.
Day Topic Done
Day 1 Python Essentials I ☐
Day 2 Python Essentials II — OOP ☐
Day 3 HTML, CSS, DOM ☐
Day 4 Automation Testing Concepts ☐
Day 5 Selenium Setup & First Test ☐
Day 6 PyTest Basics ☐
Day 7 Project: Login Flow ☐
Day 8 Locators & Self-Healing ☐
Day 9 PyTest Fixtures & Data ☐
Day 10 Page Object Model ☐
Day 11 Forms, Dropdowns, Uploads ☐
Day 12 API Testing (requests) ☐
Day 13 Mocking & Test Doubles ☐
Day 14 Project: Checkout Flow ☐
Day 15 Playwright Python Setup ☐
Day 16 Playwright + PyTest ☐
Day 17 POM with Playwright ☐
Day 18 AI Test Case Generation ☐
Day 19 Visual & AI Visual Testing ☐
Page 13
30-Day AI-Augmented Automation Testing Course (Python)
Day 20 Auth & Session Reuse ☐
Day 21 Project: Playwright + AI Review ☐
Day 22 Git/GitHub Cleanup ☐
Day 23 CI/CD Integration ☐
Day 24 Test Reporting ☐
Day 25 AI Tools Comparison ☐
Day 26 Flaky Tests & Performance ☐
Day 27 Best Practices ☐
Day 28 Capstone Part 1 ☐
Day 29 Capstone Part 2 ☐
Day 30 Portfolio Packaging ☐
Page 14