Learn - QA & Software Testing Curriculum
Full topic outline you can study from - testing types plus the skills & tools employers expect. Each section lists short learning outcomes (what you should be able to do), not long essays. Path: solid craft → advanced practice → AI-aware judgement. Jump here from the Home hub pathways.
Learn from an Experienced QA Trainer
We train learners from the very beginning to advanced level - including AI software testing - with real-world industry insight in every session.
10+ yrs
Hands-on software testing experience
6+ yrs
Teaching & mentoring testers
Beginner → Advanced
Manual, automation, API, mobile & AI
Call 9345200096 · WhatsApp to discuss your training plan.
How Practitioners Use This Hub
- Start from the risk, not the tool. Pick the quality risk your product carries - functional correctness, API contracts, device fragmentation, performance under load, data integrity, AI behaviour - and go straight to that section.
- Treat each section as a competency standard. Every bullet is an outcome a working QA engineer is expected to deliver on a real project; if you cannot demonstrate it in a codebase or a test run, it is your next sprint of practice.
- Go deep on one stack, stay fluent across the rest. Senior testers own one automation stack end to end (framework, CI, reporting) and can reason confidently about every other layer.
- Use the Home hub as the index. Pathway cards deep-link into these sections so you can jump between testing types and the skills that deliver them.
- For structured batch training or 1:1 mentoring mapped to your current role, call 9345200096 or WhatsApp.
1. Skills & Tools for Testers
What you practise with your hands every week - languages, automation, data, core craft, and team tools. Outcomes below match the Home “Skills & Tools” hub. Outcomes scale from foundation to advanced (+ AI habits later in this curriculum).
Core Craft - Test Cases, Bugs & Design Techniques
- Write clear, reusable test cases (preconditions, steps, expected result, priority)
- Distinguish scenario vs case vs checklist; keep traceability to requirements
- Log defects with title, steps, severity, priority, environment, and evidence
- Separate severity (impact) from priority (fix order) and follow a clean bug life cycle
- Apply equivalence partitioning and boundary value analysis to reduce wasteful cases
- Use decision tables for rule-heavy features; design positive and negative coverage by risk
- Organise suites so smoke, sanity, and regression stay reliable to run and maintain
Languages - Java & Python for Testers
- Write, refactor and review Java and Python code that drives automation frameworks and tooling
- Use variables, conditions, loops, methods/functions, and OOP design (encapsulation, inheritance, interfaces) applied to framework code
- Handle strings, lists/arrays, maps, and file/CSV reading for test data tasks
- Debug small failures (compile/runtime messages, nulls, wrong assertions) quickly using stack traces, logs and the debugger
- Own the code quality of Selenium, Appium and API suites - reviews, refactoring and conventions
Automation Stack - Selenium, Appium, Frameworks & BDD
- Selenium: navigate, locate, interact, assert; choose stable locators; prefer smart waits over blind sleeps
- Appium: configure capabilities and drivers, automate end-to-end Android/iOS journeys, handle gestures, contexts and device-farm execution
- Playwright / Cypress: evaluate and implement modern web tools where they outperform classic Selenium
- TestNG / JUnit: structure Java tests with annotations, suites, assertions, and clear pass/fail reporting
- Cucumber / BDD: write Given-When-Then scenarios that connect business language to automated steps
- Apply Page Object (or similar) patterns so suites stay readable and maintainable
- Decide what to automate first (stable smoke/regression) and measure maintenance cost vs speed
Data & DB - SQL, Toad & Excel
- Write practical SQL: SELECT, WHERE, JOIN, aggregates; compare UI results with stored data for CRUD flows
- Check constraints, uniqueness, and referential-integrity risks across tables and transactions
- Use a DB client such as Toad (or similar) to run queries, inspect tables, and capture evidence safely
- Build and maintain test data in Excel - matrices, data-driven rows, and clean naming for handoff
- Never mutate production data; use read-only checks and approved test environments
API Tools - Postman & REST Assured (Optional)
- Postman: create collections and environments; chain requests with variables; assert status, body, and headers
- Cover auth flows (bearer tokens, OAuth 2.0, API keys), negative paths, and smoke vs regression API suites
- REST Assured (optional): write code-level API checks in Java when the team wants suites in the same repo as automation
- Keep secrets out of shared collections and source control
Collaboration & Delivery - Jira, Git, Jenkins / CI
- Jira: create and update bugs/stories, use boards/sprints, attach evidence, and communicate status clearly
- Git: clone, branch, commit, pull, push; raise and review pull requests for automation or test assets
- Jenkins / CI: explain how tests run on build/merge; read failure signals; share logs, screenshots, and reports
- Separate real product bugs from environment flakes; keep pipelines trustworthy
Related deep dives below: Manual foundations, Documentation & techniques, Automation, API, Mobile, and Database sections expand these outcomes in context.
2. Manual Testing Foundations
SDLC & STLC
- Explain where testing sits in the Software Development Life Cycle (SDLC)
- Map STLC phases: requirements review → test planning → design → execution → closure
- Spot entry/exit criteria for a test phase
- Describe how Agile/Scrum changes day-to-day testing rhythm (often with Jira boards)
Test Case & Test Design Engineering
- Write clear, reusable test cases (preconditions, steps, expected result)
- Distinguish test scenario vs test case vs checklist
- Prioritise cases by risk and business impact
- Trace tests back to requirements (traceability habit)
- Use Excel or similar sheets thoughtfully when the team stores cases or test data that way
Bug Life Cycle
- Log defects with clear title, steps, severity, priority, and evidence
- Follow a typical bug workflow: New → Assigned → Fixed → Retest → Closed (and variants)
- Separate severity (impact) from priority (order of fix)
- Communicate bugs so developers can reproduce them quickly (Jira or your team’s tracker)
Black Box, White Box, Grey Box
- Apply black-box thinking from user/requirements view
- Apply white-box techniques - statement/branch coverage and code-path analysis
- Use grey-box insight (APIs, logs, DB/SQL hints) to design smarter tests
Positive vs Negative Testing
- Design happy-path cases that prove intended behaviour
- Design negative cases (invalid input, missing rights, broken sequence)
- Balance depth so critical risks are covered first
3. Test Documentation & Techniques
Core Documents You Should Recognise
- Test plan (scope, approach, risks, schedule)
- Test cases / suites and execution reports
- Bug reports and summary reports for stakeholders
- Keep documentation lean and decision-ready - enough for handoff and audits
Equivalence Partitioning
- Split inputs into valid/invalid classes
- Pick representative values instead of testing every possible input
- Apply partitions to forms, filters, and business rules
Boundary Value Analysis (BVA)
- Test edges: min, max, just inside, just outside
- Catch off-by-one and limit bugs early
- Combine BVA with equivalence for efficient coverage
Decision Tables
- Model complex business rules (if/else combinations)
- Find missing or conflicting rule combinations
- Turn tables into crisp test cases
Exploratory Testing
- Charter a session (mission + time box)
- Note observations, risks, and bugs while exploring
- Balance exploration with regression safety nets
- Explain when exploration finds more value than more scripted cases
4. Functional & Non-Functional Testing
Functional Testing
- Map requirements and user stories to testable behaviours
- Verify features against acceptance criteria (given / when / then thinking - useful with Cucumber later)
- Cover main flows, alternate paths, and business-rule edge cases
- Confirm error handling matches product intent (messages, recovery)
Non-Functional Testing
- Name major quality attributes: performance, security, usability, reliability, compatibility, accessibility
- Ask “how well?” not only “does it work?”
- Agree measurable targets with the team when possible (e.g. response time, supported browsers)
- Know when to escalate to specialists vs owning the first-line investigation yourself
5. Test Levels - Unit, Integration, System, UAT
- Unit: describe what small pieces of code should prove in isolation (and why developers often own this - JUnit-style thinking helps you talk the same language)
- Integration: design checks where modules, services, or APIs meet - contracts, data handoff, failure modes
- System: validate end-to-end behaviour of the product as a whole against requirements
- UAT: support user/business acceptance - real scenarios, sign-off criteria, and feedback loops
- Explain how defects found at each level change cost and ownership
- Choose the right level for a given risk instead of testing everything only at UI
6. Smoke, Sanity & Regression
- Smoke: run a short “is the build alive?” suite before deeper testing
- Sanity: focus quickly on a fix or narrow area after a small change
- Regression: protect existing behaviour when new code lands
- Decide suite size and order for a release day (smoke → targeted → broader regression)
- Know what belongs in automation (Selenium/Appium/API) vs careful manual checks
- Track flaky or obsolete cases so regression - and CI - stays trustworthy
7. Automation Testing
When to Automate
- Automate stable, repetitive, high-value checks
- Avoid automating everything before the suite has earned its keep
- Weigh ROI: maintenance cost vs speed and confidence
- Decide smoke/regression first, then expand carefully
Languages in Automation
- Use Java or Python confidently enough to write and maintain UI/API scripts
- Keep code readable: naming, small methods, consistent patterns
Framework Thinking
- Structure tests so they are readable and maintainable
- Separate test data, locators, and assertions where useful
- Prefer clear naming and consistent patterns over “clever” code
- Organise Java suites with TestNG or JUnit (annotations, groups, suite XML / runners)
Selenium
- Browser automation in depth: navigation, robust locators, interactions, assertions, frames, windows, alerts
- Understand locators and why brittle selectors fail
- Design and run maintainable end-to-end suites against real web applications
Playwright & Cypress
- Modern browser automation concepts (multi-browser, auto-waits, fast feedback)
- Write concise UI checks with reliable assertions
- Compare when Selenium vs Playwright/Cypress may fit a team
Appium (Mobile Automation)
- Configure capabilities and drivers for real-device Android/iOS automation (see Mobile section for platform mindset)
- Locate elements reliably, apply waits, and automate complete user journeys including gestures
- Wire suites into CI on device farms; judge setup cost, device variance, and when manual still owns the risk
Cucumber / BDD
- Write feature files in clear business language (Given-When-Then)
- Map steps to automation code without burying logic in the feature file
- Use BDD where collaboration value is high - not as decoration on every test
Waits & Stability
- Prefer explicit/smart waits over blind sleeps
- Diagnose flaky tests (timing, selectors, environment)
- Build habits that keep CI green
Page Object Model (POM)
- Encapsulate page structure and actions
- Reduce duplication across tests
- Keep page objects thin; keep assertions in tests (common good practice)
CI Integration (Jenkins & Friends)
- Run automation on every meaningful build/merge (Jenkins or similar CI)
- Read CI failure signals: real bug vs environment flake
- Share artefacts (screenshots, logs, reports) for faster debugging
- Keep test code in Git so pipelines and teammates share one source of truth
8. API Testing
REST Fundamentals in Depth
- Understand resources, HTTP methods (GET, POST, PUT, PATCH, DELETE)
- Read request/response structure (headers, body, query params)
- Relate API behaviour to UI features
Postman Skills
- Create collections and environments
- Chain requests with variables
- Organise smoke and regression API suites
- Assert status, body fields, headers, and response-time thresholds inside Postman
Status Codes & Contracts
- Interpret common codes (2xx, 4xx, 5xx) in context
- Validate response schema and key fields
- Check error messages for clarity and safety
Auth & Security at the API Layer
- Work with common auth patterns (bearer tokens, OAuth 2.0, API keys)
- Test unauthorised and forbidden paths thoughtfully
- Never hard-code secrets in shared collections
REST Assured (Optional Java Path)
- Write fluent API assertions in Java when the team wants code-level suites
- Reuse the same Java skills you use with Selenium/TestNG/JUnit
- Choose Postman for exploration and REST Assured for repeatable pipeline checks when both fit
Assertions
- Assert status, body fields, headers, and timings
- Negative tests: bad input, missing auth, wrong resource
- Document expected business rules beside technical checks
9. Mobile Testing
Android & iOS Mindset
- Know platform differences that affect testing (permissions, back behaviour, store rules)
- Test interrupts: calls, notifications, low battery, network flips
- Cover install/update, login, offline, and device rotation scenarios
Appium Automation
- Drive real-device Android/iOS automation: capabilities, drivers, stable locators, and explicit waits
- Automate full mobile journeys (often with Java or Python bindings), including gestures and context switches
- Run suites on device farms in CI; know when emulators fall short and manual still owns the risk
Device Labs & Real Devices
- Why emulators/simulators are not enough alone
- Plan coverage across OS versions and screen sizes
- Capture logs/screenshots for reproducible bug reports
10. Performance & Security Testing
Performance - Load & Stress
- Explain load testing (expected concurrent use) vs stress testing (beyond normal limits)
- Design soak/endurance runs to expose memory leaks and degradation over time
- Analyse core metrics: response time, throughput, error rate
- Spot when “slow” is a product risk, not only a server issue
- Collaborate with specialists; own clear reproduction notes and environments
Security Testing for QA
- Raise flags for weak auth, sensitive data in logs/UI, and injection risks (SQLi, XSS) aligned to OWASP Top 10
- Test role-based access (what each user should/shouldn’t see)
- Practise safe handling of test data and credentials
- Escalate - do not “hack” production or systems you are not authorised to test
11. Usability, Compatibility & Accessibility
Usability Testing
- Observe where users hesitate, mis-tap, or abandon a flow
- Check clarity of labels, errors, and empty states
- Separate preference opinions from clear usability defects
- Capture evidence (notes, screenshots) that product can act on
Compatibility Testing
- Build a practical matrix: browsers, OS versions, devices, screen sizes that matter to your users
- Prioritise by analytics/risk instead of endless combinations
- Note rendering, layout, and behaviour differences with clear repro steps
Accessibility Testing (WCAG 2.x)
- Test keyboard-only navigation for key journeys
- Check contrast, focus visibility, and meaningful labels/alt text at a practical level
- Understand why assistive tech (e.g. screen readers) changes how quality is judged
- Raise inclusive defects early; know when to involve specialists
12. Database & Localization Testing
Database Testing
- Compare UI results with stored data for critical CRUD flows using practical SQL
- Check constraints, uniqueness, and cascade/delete behaviour across related tables
- Use a client such as Toad (or similar) to inspect data and capture query evidence safely
- Spot data migration and seed-data risks before release
- Use safe queries/logs with permission - never mutate production data
Localization (L10n) & Internationalization
- Test language packs: truncated text, missing keys, mixed languages
- Validate date, time, currency, and number formats for target locales
- Check RTL/layout stretch issues where relevant
- Flag culturally sensitive defaults or hard-coded strings
13. AI Software Testing (Using AI as a Testing Assistant)
Practise with the same class of tools senior teams use day to day: Claude, Claude Code, GPT / ChatGPT, Codex, Gemini, Grok, and IDE assistants such as Cursor and Copilot. Treat every model output as a draft you review, harden, and own.
Models, Agents & Code Assistants
- Use Claude and Claude Code for deep requirement analysis, suite design reviews, and framework refactors
- Use GPT / ChatGPT and Codex for prompt-driven test generation, helper scripts, and fast iteration on cases
- Use Gemini and Grok as alternate reviewers to challenge coverage gaps and risk assumptions
- Apply Cursor and Copilot as code assistants for Selenium, Appium, Page Objects, TestNG/JUnit, and CI glue - without pasting secrets into chats
Prompt-Driven Test Generation
- Generate draft test ideas and cases from requirements, then criticise completeness, oracle quality, and risk coverage
- Turn acceptance criteria into structured suites (smoke, regression, negative paths) with clear expected results
- Iterate prompts with constraints, examples, and stop-conditions so output stays usable for engineers
AI-Assisted Exploration
- Drive AI-assisted explorers and prompt sessions to surface edge cases and alternate user journeys
- Charter time-boxed exploration, capture session notes, and convert strong findings into durable regression coverage
- Summarise logs or failure clusters to speed triage, then verify each claim against real evidence
Flaky-Test Analysis
- Use AI-assisted signals to spot unstable tests across timing, selectors, data, and environment
- Separate product bugs from flakes; improve waits, locators, and test design based on recurring patterns
- Keep CI trustworthy by retiring or rewriting tests that cannot earn a stable signal
Code Assistants for Selenium, Appium & Framework Work
- Accelerate locator strategy, waits, Page Object / screen patterns, and maintainable suite structure with AI pair-coding
- Scaffold Appium capabilities, gesture flows, and device-farm hooks - then harden them in real runs
- Review generated framework code for flakiness, secrets leakage, and unreadable abstractions before merge
Healthy Habits with AI Tools
- Treat AI output as a draft - you own the final quality decision
- Keep secrets, tokens, and production data out of prompts and shared chats
- Prefer tools and workflows your team can audit, version, and maintain
14. Testing AI Systems & Skills for an AI World
QA careers grow when you can evaluate intelligent products with the same rigour you bring to any high-risk release. This is the advanced end of the craft → advanced + AI path: LLM / RAG products, prompt regression, and hallucination / safety checks.
Prompting for Testers
- Write clear prompts that produce useful test ideas, checklists, and risk questions
- Iterate prompts: add constraints, examples, acceptance criteria, and failure modes
- Ask Claude, GPT, Gemini, or Grok to challenge your assumptions and list risks you missed
Evaluating LLM & RAG Products
- Check correctness, completeness, consistency, and grounding against source context (RAG)
- Design tests for retrieval quality: wrong docs, stale docs, empty retrieval, and citation honesty
- Define pass/fail when answers are probabilistic (rubrics, golden sets, human review gates)
- Measure latency, cost, and fallback behaviour under degraded model or tool failures
Prompt Regression & Hallucination / Safety Checks
- Build prompt regression packs: fixed prompts, expected traits, and change detection when models or prompts move
- Hunt hallucinations and overconfident wrong answers; record repro prompts and severity
- Exercise safety and policy boundaries: refusals, jailbreak-style probes (within policy), PII leakage, and unsafe advice
- Validate fallback UX when the model abstains, times out, or returns low-confidence output
Data Quality Mindset
- Appreciate how bad training / eval data creates bad outcomes for users
- Spot PII risks and labelling mistakes in datasets and their impact on model behaviour
- Ask: “What would make this model fail for real users?”
Python & Java for Testers (AI-Era Practice)
- Write and maintain scripts that power automation and tooling (Python and Java)
- Automate small repetitive tasks (parse CSV/Excel rows, call an API, rename files)
- Pair with Claude Code, Codex, Cursor, or Copilot to move faster - still read every line you commit
AI Ethics & Bias Evaluation
- Understand that biased data can harm users unfairly
- Document risks clearly for product and leadership
- Stay professional: privacy, consent, and responsible use matter in testing too
15. Career Path & How to Join Training
Typical Growth Path
- Foundations - test case writing, bug reporting, test design techniques, manual craft
- Team tools - Jira, Excel for test data, Git workflows, SQL & Toad
- Map the landscape - functional vs non-functional, levels, smoke/sanity/regression
- Depth - Java or Python + one strong track (Selenium web automation or API/Postman) with TestNG/JUnit or Cucumber as needed
- Breadth - Appium/mobile, Jenkins/CI, performance/security, UX/a11y, DB/l10n; REST Assured optional
- Modern edge - Claude, Claude Code, GPT, Codex, Gemini, Grok; prompt-driven generation, flaky-test analysis, LLM / RAG evaluation, prompt regression, hallucination / safety checks
- Job readiness - portfolio of practice projects, clear stories in interviews
How Paid Training Helps
- Structured syllabus with feedback (batch) or personalised coaching (1:1)
- Practice-focused sessions so concepts and tools stick
- Guidance on what to learn next for your background (fresher / switcher / upskiller)
Ready to join batch classes or 1:1 mentoring?
Call or WhatsApp to discuss your needs and training plan. Fees are based on that conversation - no fixed prices listed here.
- Call / WhatsApp: 9345200096 · WhatsApp chat
- Email: Coming soon
- Tell us: your current level, preferred track (manual / automation / API / mixed), tools you want (e.g. Selenium, Appium, SQL), and batch vs 1:1.
QA Learning Hub - learn software testing with clarity, practice, and career focus.