SDET CI/CD with Docker + UI & API Automation

Complete Package Curriculum

The Journey: API Architecture → RestAssured Framework → State Injection → Design Patterns → Docker → GitHub Actions → Jenkins

Package Overview

This package is a two-phase, end-to-end SDET mastery program. In Phase 1, you build a production-grade hybrid automation framework from scratch — starting from raw API mechanics, moving through enterprise design patterns, and landing on state injection techniques that make your test suite faster and dramatically less flaky. In Phase 2, you take that framework and ship it at scale — containerizing execution with Docker, wiring up cloud pipelines with GitHub Actions, and building on-premise automation via Jenkins.

By the end of both phases, you won't just know how to write tests. You'll own the full delivery lifecycle: from framework architecture to production pipeline.

Who This Package Is For

• QA & Automation Engineers who want to move from tool-level knowledge to system-level mastery.
• Manual Testers transitioning into automation who need a structured, code-first path.
• SDETs looking to own both the quality layer and the DevOps delivery layer.
• Engineers stuck on local execution who need real CI/CD pipelines backing their frameworks.

Prerequisites

• Basic familiarity with Java programming and object-oriented concepts.
• Fundamental understanding of how web applications work (requests, responses, HTTP basics).
• IntelliJ IDEA installed with basic Git command-line familiarity.
• No prior Docker, CI/CD, or RestAssured experience required — both phases start from first principles.

PHASE 1 — Master Hybrid Test Automation UI + APIs Framework

Build the Quality Layer: API Fundamentals to Enterprise-Grade Automation

A code-heavy, architecture-first masterclass that takes you from understanding what an HTTP request is to designing a multi-layered, state-injected RestAssured framework using production design patterns. You will stop clicking around in Postman and start building the kind of automated API validation engines that engineering teams actually rely on.

Module 1 — API Fundamentals & Client-Server Architecture

• Core Infrastructure: Client-Server architecture, URL anatomy, and the anatomy of an HTTP request.
• HTTP Protocol Deep Dive: Comprehensive coverage of HTTP Methods, Status Codes, Headers, and Content-Type validation across real-world scenarios.
• Security Essentials: HTTP vs. HTTPS distinctions, authentication mechanisms, and authorization flows — what every SDET needs to know before touching a test.

Module 2 — Pragmatic Manual API Testing with Postman

• Environment Execution: Workspace setup, parsing Swagger/OpenAPI documentation, and managing URL encoding edge cases.
• Request Lifecycle: Configuring, parameterizing, executing, and validating GET and POST requests against live endpoints.
• Collection Management: Building modular Postman collections and chaining requests for workflow-level testing — not just isolated endpoint checks.

Module 3 — RestAssured Foundations & Validation Engine

• Setup & BDD Semantics: Integrating RestAssured via Maven and structuring tests using Given/When/Then — clean, readable, and maintainable from day one.
• Hamcrest Matchers Deep Dive: Type-safe, fluent assertions across collections, maps, numbers, and custom string matching logic.
• Logging & Blacklisting: Configuring log().ifValidationFails() and blacklisting sensitive tokens from console output — production-safe logging practices.
• Specification Reusability: Building RequestSpecification and ResponseSpecification objects via SpecBuilder classes to standardize global validations across the entire suite.

Module 4 — Data Serialization & Complex JSON Payloads

• POJO Architecture: Engineering Plain Old Java Objects from scratch to represent deeply nested, complex JSON schemas.
• Serialization Mechanics: Using Jackson DataBind's ObjectMapper to translate Java objects directly into dynamic API payloads.
• Deserialization Strategy: Extracting complex API responses back into strongly typed POJO representations for precision verification.
• Design Patterns in Practice: Implementing the Builder Pattern for nested data objects — a reusable, scalable approach to test data generation.

Module 5 — Enterprise-Grade Automation Framework Architecture

• Industrial Case Study: Building an abstract framework layer around production-grade APIs, including OAuth 2.0 authentication flows.
• State Injection: Programmatic token extraction, access token refresh mechanics, and API-level state injection to bypass expensive UI flows and eliminate flakiness.
• Framework Scalability: Centralizing configuration via config.properties file readers, constants management, and generating dynamic test data with Java Faker.
• Reporting & Execution: Parallel execution setup with custom Allure Reports embedded with runtime request and response payload attachments for full diagnostic traceability.

PHASE 2 — Become Proficient Automation Tester with CI/CD

Ship the Quality Layer: Containerized Execution to Production Pipelines

A DevOps-heavy, infrastructure-first continuation that takes the framework you built in Phase 1 and transforms it into a scalable, containerized, pipeline-backed delivery engine. You will learn how real engineering teams run test suites — not locally, but on cloud infrastructure, inside Docker containers, triggered by code pushes.

Module 6 — Framework Refactoring & Property Management

• Project Setup & Refactoring: Importing and structuring codebases cleanly in IntelliJ — page class standards, naming conventions, and directory hygiene.
• Global Configuration Management: Setting up AppConstants and externalizing environment-level properties for flexible, multi-env execution.
• Exception Handling & Debugging: Structured triage of real-world framework exceptions — runtime errors, execution failures, and pipeline bugs debugged step by step.

Module 7 — Parallelization, Parameters & Command-Line Power

• Framework Test Updates: Preparing test cases for high-concurrency environments — thread safety, test isolation, and shared state elimination.
• Dual-Layer Parallel Execution: Multi-threaded execution via both TestNG XML configurations and Maven pom.xml plugin settings simultaneously.
• Advanced Test Controls: Parameterizing TestNG workflows and shifting entirely to command-line execution via Maven CLI (mvn clean test).

Module 8 — Enterprise Logging & Parallel-Safe Reporting

• Advanced Logging Infrastructure: Framework-wide Log4J integration for granular, structured tracking across all execution threads.
• Thread-Safe Reporting: Configuring Extent Reports for accurate, visually clean, parallel-safe output — no corrupted logs, no missing entries under high concurrency.

Module 9 — Containerization with Docker & Distributed Selenium Grid

• Docker Foundations: Container fundamentals, installation, and container lifecycle management from first principles.
• Multi-Container Architecture: Structuring unified test run-times using Docker Compose — coordinated service startup, teardown, and environment isolation.
• Cross-Browser Container Execution: Launching and managing headless and headed test runs inside Dockerized Chrome and Firefox containers.
• Selenium Grid on Docker: Setting up a distributed Selenium Grid hub and node architecture on Docker, using Docker Hub to provision infrastructure on demand.

Module 10 — CI/CD Pipelines via GitHub Actions

• Version Control Integration: Efficient code and framework pushes to GitHub repositories — branch strategies and push hygiene for CI-ready codebases.
• GitHub Actions Workflows: Writing custom YAML pipelines, configuring runner environments, and executing test suites on GitHub's cloud infrastructure against real commits.
• End-to-End Workflow Optimization: Final pipeline structural adjustments for stable, repeatable, failure-resistant continuous integration runs.

Module 11 — On-Premise & Cloud CI/CD via Jenkins

• Jenkins Architecture: Installing, running, and navigating Jenkins locally — admin panel, credential management, and job structure.
• Plugin Architecture & Customization: Finding, configuring, and managing critical Jenkins plugins to extend automation pipeline capabilities.
• Maven Job Integration: Mapping Maven builds directly inside Jenkins pipelines to trigger automated regression runs on commits or scheduled intervals.

Combined Learning Outcomes

By completing both phases of this package, you will be able to:

• Design frameworks from scratch — no boilerplate, no templates, clean object-oriented architecture.
• Inject state programmatically — bypass UI flows with API-level setup to eliminate flakiness at the root cause.
• Apply enterprise design patterns — Builder Pattern, SpecBuilder abstraction, and config-driven data management.
• Parallelize at multiple layers — TestNG XML, Maven plugins, and Selenium Grid concurrency in a single suite.
• Containerize test infrastructure — Docker and Docker Compose for fully isolated, reproducible execution environments.
• Build and own CI/CD pipelines — GitHub Actions and Jenkins, from zero YAML to end-to-end trigger-based automation.
• Generate diagnostic-grade reporting — Allure, Extent Reports, and Log4J producing actionable output for both developers and stakeholders.

What's Included

Phase 1 — Hybrid Framework

• Structured video lectures covering API testing from fundamentals to framework
• The REST API Handbook — request lifecycle reference guide
• Japneet's Custom API Testing Notes — real interview questions with exact code configurations
• Architecture mindmaps and visual diagrams (client-server handshakes, token flows, framework structure)
• Full production-ready framework repository with every line of code from the masterclass

Phase 2 — CI/CD Mastery

• 32 targeted HD video lectures across framework optimization and pipeline orchestration
• Ready-to-use configuration templates — docker-compose.yml, GitHub Actions .yaml workflows, parameterized testng.xml
• Sample codebase repository used throughout the course for direct benchmark comparison

Two courses. One complete SDET delivery pipeline. Build the framework. Then ship it.