The QA Skills Path for 2026: What to Learn, in What Order

TL;DR Learning testing tools in whatever order they reach you leaves you with a suite that runs but can't say what it covers, or whether any test in it can fail. This QA roadmap 2026 uses one order instead: design the tests, then one language and the API, the UI, the checks functional tests miss, the pipeline, and AI last. Every step lands on the same checkout.

Do this: Write down the last feature you tested and, next to it, which tests you picked and why. If the "why" column is empty, start with part 2.

A checkout with a quantity field, a discount code and three payment methods already has millions of combinations. You will never run them all. It is tempting to start by learning a tool, but a tool only runs the tests you hand it. Nobody tells it which ones.

The QA Skills Path, in seven parts:

1. The QA Skills Path for 2026: What to Learn, in What Order (you are here): the route and why it runs in this order.
2. Test Design Techniques: Pick the Few Tests That Find Bugs: from a spec to the tests worth running, then exploring for the rest.
3. Test Below the UI: Your First API Tests in Python: one language, learned on the API.
4. Why Your UI Tests Flake, and the Fix for Web and Mobile: locators, waits and setup that make red mean something.
5. Green Tests, Broken Checkout: The Checks Functional Tests Miss: performance, security, accessibility, contracts.
6. Quality Gates in CI: Make Your Tests Block a Bad Merge: tiers, flaky tests and test data in the pipeline.
7. AI in Testing: Use It Without Trusting It, and Test AI Features: where AI helps, and how to test it.

Start from a spec, not a tool

Every part of this series tests one feature. The repo's guides share an unnamed online-shop checkout; I'll call it the ShopLite checkout. The rules, prices and bug numbers are the repo's own. Four of its six rules do most of the work:

The other two cover the code format and the order states. Six rules already hide an edge case at €50.00, a question the spec never answers, and a bug that only shows when you change the cart after applying a code.

Why this order

Each skill depends on the one before it. Learn them out of order and you end up automating something you can't yet judge.

1. Test design first. "I tested 7 boundary values" can be checked. "I tested it a lot" cannot. Without it, automation just repeats your guesses faster.
2. One language next, on the API. I put programming second on purpose: you can't automate API, web or mobile checks without one language.
3. The UI after the API, because good UI tests set their data up through the API and only verify through the browser.
4. The checks functional tests miss: load, security, accessibility, and the contracts between services.
5. The pipeline, so the tests block a bad merge instead of waiting for someone to run them.
6. AI last. You are the one reviewing what it proposes, and that takes every skill above.

flowchart LR
  D[Test design] --> L[One language + API]
  L --> U[Web and mobile UI]
  L --> S[Load, security, a11y, contracts]
  U --> C[CI gate]
  S --> C
  D --> A[AI: review what it proposes]
  C --> A

What the series leaves out

These are in the repo, but not taught here:

• English for QA and IELTS preparation, which the repo itself keeps outside the technical path.
• Agile ceremonies and test management.
• The deep Linux, Docker, Kubernetes, database, Kafka and AWS guides. Part 6 uses one Linux recipe and one Compose file; the rest is reference for when you need it.

Try it

Clone the repo and run the Playwright starter, the smallest suite in it. It needs Node.js 20 or later:

git clone https://gitlab.com/agentic-fx/qa-skills-path.git
cd qa-skills-path/04-web-ui-testing/playwright-starter
npm install
npx playwright install --with-deps
npx playwright test --project=chromium

Moving over from manual testing? Manual to Automation Testing in Six Months: Skip the Tutorial Loop covers the job move; this series covers the skills.

You now have a suite that runs, which is the easy part. The ShopLite spec and its six rules are still untested. Which few values for SAVE10 are worth a test, and what do you do with the rule the spec forgot? Part 2, Test Design Techniques: Pick the Few Tests That Find Bugs, turns those six rules into a short list of tests you can defend.

Read this with your AI

Read the post "The QA Skills Path for 2026: What to Learn, in What Order".
1. Summarise the route in 7 bullets, one per part.
2. Ask me 3 questions about my current skills; wait, then tell me which part to start with.
3. Give me a 10-minute exercise: list the rules of one feature I test, the way the post lists R1 to R6.