The 90-Day Manual QA to Modern SDET Roadmap: Stop Applying, Start Building

Sarah had sent 200 job applications for SDET roles over six months. Zero callbacks. Her resume looked solid — five years of manual testing, expertise in test planning, a certification in quality assurance. But the rejections kept coming.

On a Wednesday evening, frustrated enough to skip the application sites entirely, she spent two hours building something different. Not a course certificate. Not another portfolio template project. A real GitHub repository with three working API tests, a RestAssured framework, and a GitHub Actions pipeline that ran green on every push.

She added a shiny CI/CD badge to her LinkedIn profile, linked the repo, and went to bed.

Ten days later, she had four interview calls from companies that hadn’t responded to her last 50 applications.

The difference wasn’t her skills. She’d always known testing. The difference was proof.

Why Manual QA Resumes Fail in the Modern Market

The testing world in 2026 has moved. Automation is no longer a nice-to-have skill for QA professionals — it’s the baseline expectation. Companies aren’t looking for testers who can click through applications and document bugs. They’re looking for engineers who can write test code, integrate testing into CI/CD pipelines, and own quality as part of a product development lifecycle.

A resume that says “Manual Test Execution and Documentation” competes with 500 other candidates with similar resumes. A GitHub profile with a working test framework, real CI/CD integration, and documented code examples? That converts to interviews because it answers the hiring manager’s unspoken question: “Can this person actually write and ship test code?”

This roadmap is built on one core principle: You don’t need months of preparation to become interview-ready for SDET roles. You need structure, daily commitment, and most importantly, something to show for your work.

The 2-Hour Portfolio Project That Changes Everything

Before we map out the full 90 days, let’s build momentum with a single project you can complete tonight. This is your proof of concept — a real, working test framework with CI/CD integration.

Here’s what you’re building: three API tests for a public API (we’ll use JSONPlaceholder), pushed to GitHub with an automated CI/CD pipeline that runs your tests on every commit and displays a passing status badge.

Step 1: Create Your GitHub Repository

Go to github.com, create a new public repository called “qa-api-tests.” Clone it locally. This is your starting point.

Step 2: Write Three API Tests

We’ll use RestAssured with Java because it’s widely used in enterprise SDET roles.

import io.restassured.RestAssured;
import org.junit.Test;
import static io.restassured.RestAssured.*;
import static org.hamcrest.Matchers.*;

public class JSONPlaceholderAPITests {

    @Test
    public void testGetUserById() {
        given()
            .baseUri("https://jsonplaceholder.typicode.com")
        .when()
            .get("/users/1")
        .then()
            .statusCode(200)
            .body("id", equalTo(1))
            .body("name", equalTo("Leanne Graham"));
    }

    @Test
    public void testGetPostsReturnsList() {
        given()
            .baseUri("https://jsonplaceholder.typicode.com")
        .when()
            .get("/posts")
        .then()
            .statusCode(200)
            .body("size()", greaterThan(0))
            .body("[0].id", notNullValue());
    }

    @Test
    public void testCreatePostReturnsCreated() {
        given()
            .baseUri("https://jsonplaceholder.typicode.com")
            .header("Content-Type", "application/json")
            .body("{\"title\":\"Test Post\",\"body\":\"This is a test\",\"userId\":1}")
        .when()
            .post("/posts")
        .then()
            .statusCode(201)
            .body("title", equalTo("Test Post"));
    }
}

Three tests covering GET requests (single resource, multiple resources) and a POST request. Save this file in src/test/java/, commit it to Git. You’ve now written more real test code than 80% of job applicants.

Step 3: Add CI/CD Pipeline with GitHub Actions

Create .github/workflows/test.yml in your repo:

name: API Tests

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Set up JDK 11
        uses: actions/setup-java@v3
        with:
          java-version: '11'
      - name: Run tests with Maven
        run: mvn test

Commit and push. GitHub Actions will automatically run your tests on every push. Within minutes, you’ll see a green checkmark next to your commits.

Step 4: Add the CI/CD Badge

Go to your GitHub repo, click “Actions,” find your workflow, click the three dots, select “Create status badge.” Copy the markdown and add it to your README.md and LinkedIn profile. That badge is worth more than three job application rejections.

The 90-Day Roadmap: Month by Month

The portfolio project above is momentum. This roadmap is direction. The goal is not to make you a senior SDET — that takes years. The goal is to make you interview-ready.

Commitment: 1-2 hours daily, most days. If you can’t commit to that, this roadmap won’t work. Be honest with yourself now.

Month 1: Automation Fundamentals (Weeks 1-4)

Week 1: Programming Basics. Pick one language: Python or Java. Not both. Python is faster to learn. Java is more aligned with enterprise test frameworks. Either choice is correct. Spend 5-7 hours learning variables, functions, control flow, and OOP fundamentals.

Week 1 Deliverable: A simple script that reads data from a CSV file and prints it to the console.

Week 2: Selenium/Playwright Fundamentals. Learn locating elements (CSS selectors, XPath basics), waiting for elements, interacting with elements (click, fill, submit), and basic assertions.

Week 2 Deliverable: Three browser automation scripts against a practice site — automating a login flow, form submission, and data validation.

Week 3: Test Framework Foundations. Learn the Page Object Model (POM) — separating test logic from page interactions. Learn a test runner (JUnit for Java, pytest for Python).

Week 3 Deliverable: Refactor your Week 2 scripts into a POM structure with at least two page object classes and two test files.

Week 4: Project #1. Build a test suite for a publicly available website with POM structure, 5-10 tests, and a README documenting how to run it. Push to GitHub with a CI/CD pipeline.

Month 2: API Testing and CI/CD (Weeks 5-8)

Week 5: REST API Fundamentals. HTTP methods (GET, POST, PUT, DELETE), status codes, request/response structure, and authentication. Use Postman as your exploration tool.

Week 5 Deliverable: A Postman collection with 10+ requests against a public API, organized into folders.

Week 6: API Testing in Code. Convert Postman knowledge into test code with RestAssured (Java) or Requests (Python). Validate status codes, headers, body content, and data types.

Week 7: CI/CD Integration. GitHub Actions workflow syntax, triggering tests on push and pull request, test reporting, failure notifications.

Week 8: Project #2. Comprehensive API test suite (15-20 tests), organized into logical classes, with helper methods and GitHub Actions CI/CD.

Month 3: Advanced Patterns and Portfolio (Weeks 9-12)

Week 9: POM Deep Dive + Test Data. Externalize hard-coded test values into data files (CSV, JSON). Learn data-driven testing and parameterized tests.

Week 10: Test Reporting. Allure Reports or ExtentReports — HTML reports with execution timelines, failure details, and screenshots. Implement screenshot capture on test failure.

Week 11: Docker Basics. Write a Dockerfile for your test project. Run tests in containers for consistency between local and CI/CD environments.

Week 12: Project #3 — The Portfolio Masterpiece. One comprehensive framework incorporating UI tests with POM, API tests, test data management, professional reporting, Docker, and CI/CD with passing badges.

What This Roadmap Will and Won’t Do

What it will do: Make you interview-ready. Give you hands-on experience with tools used in real SDET roles. Provide portfolio proof that you can write test code.

What it won’t do: Make you a senior SDET overnight. Guarantee you a job. Teach advanced concepts like ML in testing or performance testing at scale.

The gap between “knowing automation” and “demonstrating automation” is why Sarah got zero callbacks before the portfolio project and four after. This roadmap closes that gap.

Start Today: Week 1 Action Items

Monday: Choose your language (Python or Java). Download your IDE (VS Code or IntelliJ). Complete 1-2 hours of basic syntax.

Tuesday-Wednesday: Continue language fundamentals. Build a simple script that reads a file and processes data.

Thursday: Create your GitHub account. Create your first public repository.

Friday: Install Playwright or Selenium. Write a script that opens a browser, navigates to google.com, searches for something. Commit to GitHub.

Weekend: Repeat on 2-3 different websites. Explore different locator strategies. Push each attempt to GitHub. By end of Week 1, you should have 5+ commits and code that actually runs.

Frequently Asked Questions

I don’t have a programming background. Will this work?

Yes, if you commit to it. Manual QA experience actually gives you an advantage — you understand testing concepts, workflows, and edge cases. Programming is just the tool to express that understanding.

Should I choose Python or Java?

If unsure, pick Python. It’s syntactically simpler and faster to prototype. Java is more common in enterprise automation. Check the job postings at companies you’re targeting.

Do I need to finish the full 90 days before applying?

No. After Month 2 (8 weeks), if you have two polished portfolio projects with working CI/CD, start applying. Don’t wait for perfection.

What if I can only commit 30 minutes daily?

It’ll take 5-6 months instead of 3. The structure doesn’t change, just the pace. Consistency matters more than speed.

How important is GitHub?

GitHub is everything. It’s your portfolio, your proof, and your credibility. Public projects are non-negotiable. Private repos don’t count for job hunting.

The Bottom Line

The old playbook — apply to 50 companies, get 2 interviews, hope for an offer — is dead for manual QA professionals transitioning to automation. Companies have too many candidates who claim skills they don’t have.

The new playbook: Build something real. Push it to GitHub. Make it visible. Let the code speak for itself.

This 90-day roadmap gives you the structure. Your job is the daily commitment. 1-2 hours most days for three months. In the context of a career change, that’s not a lot. In terms of interview callbacks and job offers, it’s everything.

Stop applying. Start building.

References

• Playwright Official Documentation — Browser automation framework
• Selenium Documentation — Industry standard UI test automation
• RestAssured GitHub Wiki — Java API testing framework
• GitHub Actions Documentation — CI/CD pipeline setup
• Allure Reports — Professional test reporting framework
• Play with Docker — Interactive Docker learning
• Page Object Model (Selenium) — POM best practices
• JSONPlaceholder — Free REST API for learning
• LeetCode — Coding practice platform