Many manual testers want to move into automation, and many developers want to move into SDET roles. The problem is not a lack of material. It is too much material, in no clear order. This roadmap gives you one path, step by step.
You do not need a computer science degree. You need consistent practice and a clear order of topics.
Step 1: Testing fundamentals
Automation is testing first, code second. A tool cannot tell you what is worth testing. Make sure you understand:
- What a test case is: preconditions, steps, expected result.
- Test levels: unit, integration, end-to-end.
- The testing pyramid: many fast unit tests, fewer integration tests, few end-to-end tests.
- Regression testing, smoke testing, exploratory testing.
- How to write a good bug report: steps to reproduce, expected vs actual.
If you already work as a manual tester, you have most of this. Time needed: 1-2 weeks of focused reading if you are new.
Step 2: JavaScript (or TypeScript) basics
You need one programming language. For web test automation, JavaScript/TypeScript is the most direct choice because Playwright and Cypress use it natively.
Learn, in this order:
- Variables, types, conditions, loops.
- Functions and arrow functions.
- Arrays and objects (and methods like
map,filter,find). - async/await and promises. This is the single most important topic for test automation. Almost every automation call is asynchronous.
- Imports and modules.
You do not need frontend skills like React. You are writing scripts, not building apps. Time needed: 4-8 weeks with daily practice.
Step 3: HTML, CSS selectors and the DOM
To automate a page you must be able to describe its elements:
- How HTML is structured: tags, attributes, forms, buttons, labels.
- CSS selectors:
#id,.class,[data-testid="save"], combinations. - What the DOM is and how to inspect it with browser DevTools.
- Accessibility basics: roles and labels. Modern tools locate elements by role, so this pays off directly.
Time needed: 1-2 weeks. Practice: open any website, open DevTools, and write selectors for ten elements.
Step 4: One automation framework, deeply
Pick one framework and learn it well. We recommend Playwright for a first framework; Selenium is the classic that many enterprises still require, and Cypress is a common alternative, see the comparison.
Learn in this order:
- Locators (roles, labels, test IDs, CSS).
- Actions: click, fill, select, keyboard.
- Assertions and auto-waiting.
- Test structure: describe blocks, hooks, fixtures.
- Handling real situations: dialogs, tables, dynamic lists.
- Page Object Model, organizing locators and actions into classes.
Practice every topic immediately. The TestAcademy editor exists exactly for this: real apps, an editor, and challenges, nothing to install. Time needed: 6-10 weeks.
Step 5: API testing
Most bugs live behind the UI. Testing the API layer is faster and more stable, and every serious automation role asks for it:
- HTTP basics: methods (GET, POST, PUT, DELETE), status codes, headers.
- JSON: reading and asserting on response bodies.
- Authentication: tokens, cookies.
- Writing API tests in code (Playwright's request context, or libraries like supertest).
Start with our API testing guide. Time needed: 2-4 weeks.
Step 6: Git and CI/CD
Automation only has value when it runs automatically:
- Git basics: clone, branch, commit, pull request.
- What a CI pipeline is: tests run on every code change.
- Running your test suite in GitHub Actions or a similar tool.
- Reading test reports and failure logs.
Time needed: 2-3 weeks.
Step 7: Interview preparation
When you can write clean tests for a real app, prepare for interviews on purpose:
- Review common questions: waits, locator strategy, flaky tests, framework design.
- Practice live coding: write a test for a page you have never seen.
- Prepare one project you can explain in detail. The decisions matter more than the code.
Use the interview preparation section to practice role-specific questions with explanations.
Common mistakes on this path
- Learning three frameworks at 20% depth. One framework at 90% depth gets you hired.
- Watching courses without writing code. Watching is not learning. Write tests every day, even small ones.
- Skipping JavaScript async topics. Weak async understanding causes most beginner test failures.
- Ignoring API testing. UI-only testers are limited testers.
- Waiting to feel "ready". Apply when you can build and explain a small test suite. Interviews are also practice.
A realistic timeline
With about one hour per day: 4 to 7 months from zero coding to job-ready. Faster if you already test manually and know the product side. The path is not short, but it is very repeatable, thousands of manual testers make this move every year.
Start today: open the the practice editor, pick Playwright, and complete your first challenge.