A written version of the interactive roadmap above — every station, what you'll learn, and a small thing to build — laid out for reading, reference and search.
Testing Foundations Start here
F1. What to Test
Beginner · 45 min
Testing everything is the same as testing nothing — you run out of time and trust. Learn the test pyramid (many fast unit tests, fewer integration, fewest end-to-end), risk-based prioritization, and how to reason about coverage as confidence rather than a percentage to game your way to 100%.
Skills: The test pyramid · Risk-based testing · Coverage as confidence · What NOT to test
Build it: Your suite is 95% coverage but bugs still ship. Explain how high coverage and low confidence coexist.
F2. Unit Testing
Beginner · 50 min
Unit tests are the fast, cheap base of the pyramid. Learn to write focused tests with clear arrange-act-assert structure, use test doubles (mocks, stubs, fakes) without over-mocking into meaninglessness, and treat a good failing test as precise documentation of exactly what broke and where.
Skills: Arrange-act-assert · Mocks, stubs, fakes · Avoiding over-mocking · Tests as documentation
Build it: A test mocks so much it passes even when the real code is broken. What was over-mocked, and how would you fix it?
F3. Integration Testing
Beginner · 50 min
Units that each pass can still fail together at the seams. Learn to test real interactions — a service against a real database, an API against its dependencies — using containers and test fixtures, and to find the wiring, serialization and contract bugs that unit tests, by design, can never see.
Skills: Testing the seams · Real DB & dependencies · Test containers · Contract bugs
Build it: Two services each pass their unit tests but break when integrated. Name three seam bugs unit tests structurally cannot catch.
F4. Test Design
Intermediate · 50 min
Good testers find bugs with fewer, sharper cases. Learn the classic techniques — equivalence partitioning, boundary-value analysis, decision tables, state transitions — plus the tester’s instinct for edge cases: empty, one, many, huge, negative, null, unicode, and the off-by-one that lives at every boundary.
Skills: Equivalence partitioning · Boundary values · Decision tables · Edge-case instinct
Build it: A field accepts ages 18–65. List the specific boundary values you’d test — and the three most likely to reveal a bug.
F5. Debugging & Bug Reports
Intermediate · 45 min
A bug you can’t reproduce is a rumor. Learn to isolate a defect to a minimal reproduction, bisect to the change that caused it, and write a bug report a developer can act on without a meeting — expected vs actual, exact steps, environment — because a great report is half the fix.
Skills: Minimal reproduction · Bisecting a regression · Expected vs actual · Actionable reports
Build it: Rewrite "login is broken sometimes" into a bug report a developer can act on today. What’s the missing information?
F6. Version Control & CI Basics
Intermediate · 45 min
An SDET lives in the same tools as the developers they support. Learn Git well enough to branch, review and bisect, and the shape of a CI pipeline — how tests run on every push, gate a merge, and give the fast feedback that makes automated testing worth the effort in the first place.
Skills: Git for testers · Branching & review · CI pipeline basics · Tests gating merges
Build it: A flaky test blocks every merge for the whole team. What’s the immediate mitigation, and what’s the real fix?
Automation The craft
T1. UI Automation
Intermediate · 55 min
Automating the browser is powerful and famously brittle. Learn a modern tool (Playwright, Cypress, Selenium), how to select elements that survive a redesign, wait on state instead of sleeping arbitrary seconds, and reserve end-to-end UI tests for the few user journeys that actually justify their cost and flakiness.
Skills: Playwright / Cypress · Resilient selectors · Waiting on state · When E2E is worth it
Build it: A UI test fails randomly ~10% of runs. List the three most common causes and the fix for each.
T2. API Testing
Intermediate · 50 min
API tests hit the sweet spot: broad coverage, far less flake than UI. Learn to test REST and GraphQL endpoints directly — status codes, schemas, auth, error paths and idempotency — validate contracts between services, and push as much verification as possible down from the UI to this faster, sturdier layer.
Skills: REST & GraphQL tests · Schema & contract checks · Auth & error paths · Push tests down the pyramid
Build it: An endpoint returns 200 with an error message in the body. Why is that a bug worth failing a test over?
T3. Frameworks & Patterns
Advanced · 50 min
A test suite is code, and bad test code rots faster than the product. Learn the patterns that keep it maintainable — the Page Object model, fixtures and factories for test data, DRY helpers, and clear naming — so a suite of thousands of tests stays a readable asset instead of a feared, skipped liability.
Skills: Page Object model · Fixtures & factories · DRY test helpers · Readable test suites
Build it: A selector changes and 40 tests break. What pattern would have made that a one-line fix?
T4. CI/CD Test Pipelines
Advanced · 55 min
Automation only pays off when it runs automatically on every change. Learn to wire tests into CI/CD — parallelize for speed, split fast smoke tests from slow full suites, gate deploys on results, and surface failures loudly — turning testing from a phase at the end into a continuous signal the whole team trusts.
Skills: Tests in CI/CD · Parallelization · Smoke vs full suites · Gating deploys
Build it: Your full suite takes 40 minutes and no one waits for it. Design the split that gives useful signal in under 5.
T5. Test Data & Environments
Advanced · 45 min
Flaky tests are often flaky environments in disguise. Learn to manage test data — seed it, isolate it, tear it down — and provision consistent, reproducible environments (containers, ephemeral test databases) so a test fails because the code is wrong, not because two tests fought over the same row.
Skills: Seeding & teardown · Test isolation · Ephemeral environments · Reproducible state
Build it: Two tests pass alone but fail when run together. Explain the shared-state bug and how isolation fixes it.
T6. Flaky Tests & Reliability
Advanced · 45 min
A flaky test is worse than no test: it trains the team to ignore red. Learn to hunt down flakiness — races, timing, order dependence, shared state, real network calls — quarantine the offenders, track a flake rate as a real metric, and defend the suite’s credibility as if the whole practice depends on it, because it does.
Skills: Root-causing flake · Quarantine & track · Order dependence · Defending suite trust
Build it: A test passes on retry so people just re-run CI. Why is "retry until green" a dangerous habit, not a fix?
Advanced Quality Beyond functional tests
P1. Performance Testing
Advanced · 55 min
Correct but slow is still broken. Learn load, stress and soak testing — how to model realistic traffic, find the point where latency degrades, and read the results as percentiles not averages — so you catch the scaling cliff and the slow memory leak in a test environment instead of in production at peak.
Skills: Load, stress, soak · Realistic traffic models · Percentiles not averages · Finding the cliff
Build it: Average latency looks fine but users complain. Explain why you report p99, not the mean.
P2. Security Testing
Advanced · 50 min
Quality includes "can’t be trivially broken into." Learn the tester’s slice of security — the OWASP Top 10, injection and auth flaws, input fuzzing, and dependency scanning — enough to catch the obvious, dangerous mistakes early and to know when to pull in a specialist for a real penetration test.
Skills: OWASP Top 10 · Injection & auth flaws · Fuzzing inputs · Dependency scanning
Build it: A search box reflects user input onto the page. What class of bug do you test for, and what input proves it?
P3. Mobile & Cross-Platform
Advanced · 45 min
The same app behaves differently across browsers, devices and OS versions. Learn cross-browser and mobile testing strategy — real devices vs emulators, device farms, the matrix problem — and how to test responsibly across a combinatorial explosion of platforms without trying (and failing) to cover every single one.
Skills: Cross-browser matrix · Real devices vs emulators · Device farms · Taming the matrix
Build it: You support 5 browsers × 4 OS versions × 3 screen sizes. That’s 60 combos. How do you cut it to a sane, defensible set?
P4. Test Strategy & Metrics
Advanced · 50 min
A senior SDET owns quality strategy, not just tests. Learn to define what quality means for a product, pick metrics that drive behavior (escaped defects, MTTR, flake rate) and avoid ones that don’t (raw test count, vanity coverage), and shift quality left so bugs are prevented in design, not just caught at the end.
Skills: Defining quality · Metrics that drive behavior · Shift-left · Prevention over detection
Build it: A manager wants to measure QA by "number of tests written." Explain the perverse incentive and propose a better metric.
P5. Testing AI/ML Systems
Advanced · 55 min
AI features break the rules testing assumes: the same input can give different output, and there’s no single correct answer. Learn to test non-deterministic systems — evaluation datasets, LLM-as-judge, guardrail and regression checks, red-teaming for prompt injection — the fastest-growing and least-standardized corner of quality engineering.
Skills: Non-deterministic testing · Eval sets & LLM-as-judge · Guardrail & regression checks · Red-teaming
Build it: A chatbot gives a different (but valid) answer each run. How do you write a test that isn’t either always-green or always-flaky?
P6. The SDET Career
Advanced · 45 min
QA is splitting into two futures: the manual tester and the SDET who codes. Learn where the role is going — quality engineering embedded in dev teams, building the frameworks and infrastructure others test on — and how to grow from writing test cases to owning the systems and strategy that make quality everyone’s job.
Skills: Manual QA vs SDET · Quality engineering · Building test infra · Growth to strategy
Build it: Write the six-month plan that moves you from writing test cases to owning your team’s test automation framework.