roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Prepares you for the Java SDET coding loop, where test automation is judged as software engineering. Covers core Java, JUnit, TestNG and Mockito, UI and API automation, build tooling, and DSA.
8853 of 8853 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 8853 new. 0 cut, outside your plan.
Expect something ordinary, a password-reset form or an endpoint that returns a paginated list, to arrive with one instruction: design its tests. That test-design round is what sets an SDET loop apart, and it is graded on choices: which cases belong below the browser, what you would leave to exploratory testing, where each case gets its data. Around it sit a Java coding round, usually held to a developer's bar; an automation round in which you write or review a UI or API test; from middle level up, a conversation about how a whole suite is built and run; and a behavioral interview. The automation questions are built from failures. A test passes locally and fails one run in ten on CI: is a `Thread.sleep` racing the page, a test reading rows another test left behind, or an element reference gone stale after a re-render? A suite broke the day it went parallel, because the `WebDriver` lived in a static field. A Mockito spy stubbed with `when(...)` ran the real method anyway. An API test checked the status code and nothing else, and stayed green while the endpoint returned an empty list. Where an answer stops shows the level. Fixing one flaky test is expected early. Senior candidates are pushed to the suite: which end-to-end checks a contract test should replace, how flaky tests are quarantined without hiding a real regression, and what a red build has to report before developers believe it.
A test framework is Java code that other engineers will read and maintain, which is why the plan spends its whole first stretch on the language. [Object-oriented design](/topics/lang-java-oop) is where page objects and test-data builders come from, collections and streams are what many assertions inspect, and [concurrency](/topics/lang-java-concurrency) is there for the day a suite runs in parallel and its shared state stops being safe. The stretch ends in the standard library, whose [reflection](/topics/lang-java-stdlib-reflection) and annotations are how a runner finds and calls a method marked `@Test`. Before any tool, the plan turns to the discipline: the [testing disciplines](/topics/found-testing-quality) that decide what to test and at which layer, accessibility as a quality a suite can check, and the agile methods that set when testing happens, down to a story's [definition of done](/topics/found-scrum-dod). [HTTP](/topics/proto-http), REST and OpenAPI follow because both kinds of automation after them are written against the wire: a browser test waits on and stubs the requests a page makes, and an API test asserts on status codes, headers and the schema a spec promised. UI automation is taught as problems before products. Selector strategy, [waiting and flakiness](/topics/fe-testing-e2e-waiting-flakiness), page objects and visual diffs come first, so that [Selenium](/topics/dev-selenium), Playwright and Cypress can be compared on how each handles them rather than learned as separate vocabularies, and [Appium](/topics/mob-appium) then reuses the WebDriver protocol to drive apps on phones. On the API side, a Postman collection gives way to code in [REST Assured](/topics/dev-rest-assured), and the stretch ends at mocks and [contract testing](/topics/dev-contract-testing), which check a service without the rest of the system running. Load testing and test reporting close that half. The plan then covers the ground a suite runs on: [SQL](/topics/lang-sql) to seed and verify data, the repository, the Linux runner, the [pipeline](/topics/cloud-cicd-concepts) and the containers it starts, the logs a failed run is read from, and a security scan the pipeline can run. [Algorithms](/topics/found-dsa) prepare the coding round. The JVM harness comes late, paired with the build tools rather than the language: [JUnit](/topics/dev-junit), Mockito and Testcontainers sit just before Maven and Gradle, because the questions that join them are build questions, such as why a class named `*IT` never runs under `mvn test`, or why [Failsafe](/topics/dev-maven-testing-failsafe) lets the environment shut down before it fails the build. The final module turns from code to conversation: the [behavioral round](/topics/found-behavioral) and the mechanics of the loop around it.
A posting usually names its stack, and on this plan that is the first cut to make: one browser tool of the three, one API tool, a load tool only if performance is part of the job. With two weeks left, work what you kept with importance raised to must know, and pull JUnit and Mockito forward from their place near the end, since a Java automation exercise runs under a test framework whichever tool sits on top, and JUnit is the one this plan teaches. Someone who has tested by hand for years brings the testing disciplines along; what they lack is code. With study order switched to by topics, the Java modules come before the tools that depend on them; write every exercise as a JUnit test, and give the coding round time each day. For a developer changing tracks the Java stretch is mostly review; the hours belong to test design, flaky UI tests and contract tests, the parts a developer's own unit tests rarely touch. The plan tests Java services without teaching the framework many of them are built on. Spring surfaces only where a testing tool meets it, in Spring Cloud Contract and in Testcontainers' Spring Boot integration; the framework itself belongs to the [Spring Boot roadmap](/roadmaps/spring-boot). JVM memory and garbage collection are out of scope too; for a role that owns the service as well as its tests, the [Java Backend Developer roadmap](/roadmaps/java-developer) adds them.
Expect something ordinary, a password-reset form or an endpoint that returns a paginated list, to arrive with one instruction: design its tests. That test-design round is what sets an SDET loop apart, and it is graded on choices: which cases belong below the browser, what you would leave to exploratory testing, where each case gets its data. Around it sit a Java coding round, usually held to a developer's bar; an automation round in which you write or review a UI or API test; from middle level up, a conversation about how a whole suite is built and run; and a behavioral interview.
The automation questions are built from failures. A test passes locally and fails one run in ten on CI: is a Thread.sleep racing the page, a test reading rows another test left behind, or an element reference gone stale after a re-render? A suite broke the day it went parallel, because the WebDriver lived in a static field. A Mockito spy stubbed with when(...) ran the real method anyway. An API test checked the status code and nothing else, and stayed green while the endpoint returned an empty list.
Where an answer stops shows the level. Fixing one flaky test is expected early. Senior candidates are pushed to the suite: which end-to-end checks a contract test should replace, how flaky tests are quarantined without hiding a real regression, and what a red build has to report before developers believe it.
A test framework is Java code that other engineers will read and maintain, which is why the plan spends its whole first stretch on the language. Object-oriented design is where page objects and test-data builders come from, collections and streams are what many assertions inspect, and concurrency is there for the day a suite runs in parallel and its shared state stops being safe. The stretch ends in the standard library, whose reflection and annotations are how a runner finds and calls a method marked @Test.
Before any tool, the plan turns to the discipline: the testing disciplines that decide what to test and at which layer, accessibility as a quality a suite can check, and the agile methods that set when testing happens, down to a story's definition of done. HTTP, REST and OpenAPI follow because both kinds of automation after them are written against the wire: a browser test waits on and stubs the requests a page makes, and an API test asserts on status codes, headers and the schema a spec promised.
UI automation is taught as problems before products. Selector strategy, waiting and flakiness, page objects and visual diffs come first, so that Selenium, Playwright and Cypress can be compared on how each handles them rather than learned as separate vocabularies, and Appium then reuses the WebDriver protocol to drive apps on phones. On the API side, a Postman collection gives way to code in REST Assured, and the stretch ends at mocks and contract testing, which check a service without the rest of the system running. Load testing and test reporting close that half.
The plan then covers the ground a suite runs on: SQL to seed and verify data, the repository, the Linux runner, the pipeline and the containers it starts, the logs a failed run is read from, and a security scan the pipeline can run. Algorithms prepare the coding round. The JVM harness comes late, paired with the build tools rather than the language: JUnit, Mockito and Testcontainers sit just before Maven and Gradle, because the questions that join them are build questions, such as why a class named *IT never runs under mvn test, or why Failsafe lets the environment shut down before it fails the build. The final module turns from code to conversation: the behavioral round and the mechanics of the loop around it.
A posting usually names its stack, and on this plan that is the first cut to make: one browser tool of the three, one API tool, a load tool only if performance is part of the job. With two weeks left, work what you kept with importance raised to must know, and pull JUnit and Mockito forward from their place near the end, since a Java automation exercise runs under a test framework whichever tool sits on top, and JUnit is the one this plan teaches.
Someone who has tested by hand for years brings the testing disciplines along; what they lack is code. With study order switched to by topics, the Java modules come before the tools that depend on them; write every exercise as a JUnit test, and give the coding round time each day. For a developer changing tracks the Java stretch is mostly review; the hours belong to test design, flaky UI tests and contract tests, the parts a developer's own unit tests rarely touch.
The plan tests Java services without teaching the framework many of them are built on. Spring surfaces only where a testing tool meets it, in Spring Cloud Contract and in Testcontainers' Spring Boot integration; the framework itself belongs to the Spring Boot roadmap. JVM memory and garbage collection are out of scope too; for a role that owns the service as well as its tests, the Java Backend Developer roadmap adds them.