SDET Roadmap — QE Center of Excellence

Junior

Front-end Automation (Fundamentals)

Framework Awareness

Understand Selenium vs Playwright differences
Set up and run first automated test in both

Handling Web Elements

Locate using id, name, css, xpath
Interact with inputs, buttons, dropdowns, alerts
Extract/validate text, attributes, visibility

Synchronization

Why timing issues cause failures
Apply explicit waits for dynamic elements
Replace hardcoded sleeps with wait strategies

Exceptions and Debugging

Handle NoSuchElement, StaleElement, Timeout
Read stack traces, use DevTools
Capture screenshots on failure

Assertions

Assert presence, text, attributes, navigation
Write meaningful assertion messages

Script Organization

Separate locators, actions, assertions
Apply basic POM structure
Write reusable methods

Programming (Fundamentals)

OOP Basics

Create classes/objects for test components
Use constructors to initialize test objects
Apply access modifiers to protect members

Inheritance and Polymorphism

Extend base class to share common behavior
Override methods per page/component
Abstract classes vs interfaces

Error Handling

Try/catch/finally for graceful failures
Throw meaningful exceptions
Expected vs unexpected exceptions

Data Structures

Lists and arrays for test data collections
Maps for key-value configurations
Choose right structure for the task

Working with Libraries and Packages

Manage dependencies (npm, Maven, NuGet, pip)
Import and use external libraries
Understand versioning in shared projects

Code Organization

Structure into logical folders/modules
Write readable, self-documenting code
Break logic into reusable helper methods

API Automation (Basics)

Bridge: Postman to Code

Reproduce Postman request in code
Read/navigate JSON response
Print/filter response fields

Writing Your First API Test

GET request & assert status
POST request with JSON body
Validate response field
Chain two requests

Making Tests Reusable

Extract base URL to config
Reuse headers across tests
Read body from JSON file
Read data from CSV file

Working Without a Backend

Set up Postman mock server
Write tests against mock
Simulate error responses

SQL (Fundamentals)

DDL & Schema Understanding

CREATE, ALTER, DROP
Understanding table design

All JOIN Types

INNER, LEFT, RIGHT, FULL OUTER
CROSS, SELF

Complex WHERE Clauses

Compound conditions
Subqueries in WHERE

Aggregate Functions & GROUP BY

COUNT, SUM, AVG with grouping
HAVING clause

Database Connectivity from Code

JDBC, ADO.NET, database drivers

Parameterized Queries

Preventing SQL injection
Prepared statements

Transaction Basics

BEGIN, COMMIT, ROLLBACK from code

Result Set Handling

Mapping query results to objects

Database Schema Navigation

Understanding ERDs
Foreign keys, relationships

Indexes Awareness

What they are, why they matter

Code Versioning (Fundamentals)

Version Control Fundamentals

Why version control matters
Centralized vs distributed
Clone, add, commit, push, pull

GIT Basics

Set up GIT & connect remote
Track and stage changes
Meaningful commit messages
git log and git diff

Branching and Merging

Create/switch feature branches
Merge & resolve conflicts
Merge vs rebase concepts

Collaboration Basics

Fork and clone repos
Open pull requests
Apply code review feedback

CI / CD (Fundamentals)

Core Concepts

CI vs CD (delivery vs deployment)
Where automation fits in pipeline
Read basic YAML pipeline files

Working with Pipelines

Trigger pipelines manually/push
Read logs to identify failures
Pipeline vs test failure

Running Tests in CI

Configure job for test suite
Environment variables
Publish test reports

AI for Developers

What is AI

ML vs Deep Learning
LLMs & Code Generation

AI Coding Assistants

GitHub Copilot Setup
VS Code AI Extensions

AI Safety

Reviewing AI-Generated Code
Security & License Concerns

Prompt Engineering Basics

Writing Prompts for Code

Describing needs
Specifying language/framework

Basic Patterns

"Write a function that..."
"Explain/Fix this code..."

Learning from AI Suggestions

Context Engineering Basics

Code Context Fundamentals

What Context AI Needs
File Structure Awareness
Dependency Information

Providing Code Context

Sharing Relevant Files
Explaining Architecture

Intermediate 1-4

Design Patterns Fundamentals

Page Object Model

Creation of Scripts (Established Framework)

Screen Play Pattern

Creation of Scripts (Established Framework)

Singleton

Page Factory

Testing Approaches

Testing Frameworks Implementation

TestNG - JUnit
NUnit - MsTest - Mocha
Cucumber / Specflow

Front-end Automation (Advanced)

Dynamic Xpath Strategies
Chrome DevTools Protocol
Waits/Retry Management
Improved Debugging

Advanced Web Elements

Shadow DOM / iFrames

Multi-Framework Exposure

Selenium / Playwright / Cypress

SQL (Intermediate)

Window Functions

ROW_NUMBER, RANK, DENSE_RANK, LEAD, LAG, PARTITION BY

Common Table Expressions (CTEs)

Recursive and non-recursive

Complex Subqueries

Correlated subqueries, EXISTS, IN vs JOIN

Database Testing

Data integrity validation, test data management

NoSQL Awareness

When relational vs document/key-value stores

API Automation (Intermediate)

Serialization / Deserialization

Map JSON to model objects
Handle nested arrays
Validate deserialized fields

Data-Driven & Auth

Parameterize from JSON/CSV
Token retrieval & refresh
Role-based access testing

Non-Functional Testing

Performance & response times
Stress & load testing
Concurrent request validation

JSON Schema Validation
API Test Organization
CI/CD Pipeline Integration

Mobile Automation (Intermediate)

Environment Setup

Configure Appium server
USB debugging & emulators
ADB commands
Desired capabilities

Locators & Gestures

Appium Inspector
resource-id, accessibility-id
Tap, swipe, pinch, zoom

Mobile-Specific Scenarios

Interrupts (calls, SMS)
Network conditions
Native/webview contexts

Page Object Model for Mobile
Screenshot on Failure

Code Versioning (Intermediate)

Git Workflows

Gitflow, trunk-based
Branching conventions

History Management

git revert, reset, reflog
Cherry-picking commits
Squashing & rebase

PR & Code Review

Structure reviewable PRs
Conflict resolution

Tagging and Releases

AI-Augmented Development

Advanced AI Tools

Copilot Advanced Features
Claude Code / Cursor IDE

AI for Test Automation

Generating Test Scripts
Creating Page Objects

AI-Assisted Debugging

Error Analysis
Log Interpretation

Prompt Engineering (Intermediate)

Code Generation Prompts

Framework-Specific Prompts
Test Pattern / Refactoring

Prompt Techniques

Few-Shot with Examples
Chain of Thought

SDET-Specific Patterns

Test Framework Setup
API/UI Automation Prompts
CI/CD Configuration

Context Engineering (Intermediate)

Repository-Aware Prompting

Project Structure Context
Existing Code Patterns

Multi-File Context

Related File References
Test-Code Relationships

Documentation as Context

API Specs / Requirements

Senior 1-2

Programming Advanced / Best Practices

Data Structures and Algorithms

Choose the right structure for test data management
Optimize framework code using efficient algorithms
Identify and resolve performance bottlenecks

Design Patterns

SOLID — apply across page objects, helpers, layers
Behavioral — Strategy, Observer, Command
Structural — Decorator, Adapter, Facade
Creational — Factory, Builder, Singleton

Interfaces and Abstract Classes

Define contracts between framework layers
Decouple test logic from implementation

Functional Programming

Lambdas and streams for test data
Immutability for parallel run safety

Clean Code Principles

Self-documenting code, consistent naming
Refactor into single-purpose functions
Lead maintainability-focused code reviews

Test Driven Development

Write failing tests before implementing helpers
Apply TDD to framework utilities

Automation Design Pattern Development

Framework Development

Design scalable architecture across projects
Separate layers (drivers, pages, tests, utils)
Build onboarding docs and contribution guides

POM / Page Factory

Implement POM with inheritance for shared components
Page Factory for lazy element loading
Manage complex page hierarchies

Screenplay Pattern / BDD

Implement actor, task, interaction layers
Integrate Screenplay with Cucumber

Design Patterns in Frameworks

Singleton — driver and config management
Factory — dynamic driver/browser instances
Builder — fluent test data construction
Strategy — swap execution strategies
Observer — event-based reporting/logging

Parallel Execution

Thread-safe page objects and utilities
Test data isolation across threads
Optimize suite distribution for fast feedback

Framework Governance

Define coding standards, enforce via linting
Versioned releases with changelogs
Lead framework adoption across teams

Code Versioning (Advanced)

Repository Architecture

Structure a mono-repo for multiple automation frameworks
Manage sub-modules for shared test libraries
Define and enforce branching strategies across teams
Set up branch protection rules and required reviewers

Advanced History Management

Rewrite history across multiple commits with interactive rebase
Split a large commit into smaller logical units
Use git bisect to identify which commit introduced a bug
Audit and clean up stale branches at scale

Automation Framework Versioning

Version and publish shared automation libraries
Manage dependency updates across multiple test projects
Maintain changelogs aligned to app release versions
Use semantic versioning for framework releases

Git Hooks and Automation

Enforce code style and linting on pre-commit
Run smoke tests before push with pre-push hooks
Automate ticket references and commit message validation
Share hooks across the team using a hooks manager

Governance and Best Practices

Define and document GIT conventions for QE/SDET teams
Conduct GIT training and onboarding for new team members
Audit repository health (branch count, stale PRs, commit quality)
Lead code review culture within the automation team

CI/CD (Advanced)

YAML and Pipeline as Code

Write and maintain complex multi-stage pipeline definitions
Use variables, conditions and templates to avoid duplication
Parameterize pipelines to support multiple environments
Version control pipelines alongside automation code

Docker in CI/CD

Build and maintain custom Docker images for test execution
Run test suites inside containers for environment consistency
Optimize image size and layer caching for faster builds
Use Docker Compose to spin up app and dependencies locally

Multi-Stage Pipelines

Design stages for build, test, report and deploy
Run smoke, regression and API suites in parallel stages
Configure stage dependencies and failure conditions
Trigger specific test suites based on changed file paths

Artifact Management

Publish and version test reports as pipeline artifacts
Share build artifacts between pipeline stages
Manage and publish shared automation libraries
Archive and retrieve historical test results

Infrastructure as Code

Provision test environments using IaC tools
Tear down and recreate environments on demand
Manage environment variables and secrets securely
Validate environment health before test execution

Pipeline Optimization and Governance

Identify and reduce bottlenecks in test execution time
Configure retry strategies for flaky tests in pipeline
Monitor pipeline health, failure trends and execution time
Define and document CI/CD standards for QE/SDET teams

API Automation (Advanced)

Contract Testing

Consumer-driven contracts (Pact)
Detect breaking changes

Security & Performance

OWASP top 10 automation
SQL injection/XSS testing
SLA assertions

Framework Design

Reusable API framework
Shared clients/interceptors

API Mocking at Scale
Observability & Debugging

Mobile Automation (Advanced)

Parallel & Multi-App

Parallel device execution
Multiple app contexts
Test isolation

Cloud Device Farms

SauceLabs / BrowserStack
AWS Device Farm
Cloud test analysis

Performance & Stability

Memory/CPU monitoring
App launch time metrics
Flaky test strategies

Device Virtualization
CI/CD Integration

AI Architecture

LLM Integration

OpenAI / Anthropic APIs
Azure AI / AWS Bedrock
Self-Hosted (Ollama)

AI in Test Infrastructure

AI-Powered Test Selection
Intelligent Prioritization
Self-Healing Locators

Building AI Agents

Autonomous Test Agents
Multi-Agent Orchestration
LangChain, etc.

Prompt Engineering (Advanced)

Complex Automation Prompts

Generate framework scaffolding from specs
Migrate test suites between frameworks

Meta Prompting

Prompts that generate/improve other prompts
Self-refining loops with validation
LLMs to evaluate prompt effectiveness

Prompt Patterns

Chain of thought — step by step reasoning
Few-shot — examples to shape output
Role prompting — expert personas
Self-correcting — model fixes its output
Validation chains — output feeds next prompt
Tree of thought — explore multiple paths

Multi-Model Orchestration

Combine models for generation/validation
Pipelines where models check each other
Integrate into CI/CD for test generation

Prompt Management

Version control prompts with automation code
Team prompt libraries and A/B testing

AI Agent Design

Autonomous agents that explore/test features
Goals, constraints, human-in-the-loop steps

Evaluation and Quality Control

Detect hallucinations in generated code
Automated evaluators for test cases

Context Engineering (Advanced)

System Prompt Design

Custom AI Personas
Framework-Specific Instructions

RAG for Testing

Test Doc Retrieval
Codebase Knowledge Bases

Context Architecture

Dynamic Context Loading
Token Optimization

AI-Powered Frameworks

Integrating LLMs

AI Test Data Factories
Dynamic Assertion Gen
Natural Language Steps

Intelligent Reporting

AI-Generated Reports
Failure Analysis
Trend Prediction

Self-Healing Automation

Locator Recovery
Test Self-Repair
Adaptive Wait Strategies

SDET Practice Leadership

Technical Mentorship

Coaching Junior/Mid SDETs on Framework Design
Running Code Review Culture & Standards
Knowledge Sharing Sessions & Tech Talks

Automation Strategy & Governance

Org-Wide Automation Standards & Tooling Decisions
Building & Maintaining Automation Playbooks
Quality Gates & DoD for Automation

Cross-Team Influence

Partnering with QE Leads on Test Strategy
Advising Dev Teams on Testability
Representing Automation in Architecture Reviews

Framework Adoption & Onboarding

Onboarding Paths for New SDETs
Documentation, Templates & Starter Projects
Measuring Adoption & Developer Experience

Metrics & Continuous Improvement

Automation Health Metrics (Coverage, Flakiness, Exec Time)
Eliminating Technical Debt in Test Infrastructure
Retrospectives on Automation Practices

Software Development Engineer in Test - Roadmap