Apply now »

Job Title: Lead Senior Associate | QA | Bengaluru | Engineering as a Service/ Operate

Key Languages, Frameworks & Libraries

Languages: Java (architect), TypeScript (architect), Shell (platform design), GraphQL (federated strategy),YAML (CI/CD architecture)
TestFrameworks: Selenium WebDriver, Playwright, TestNG, Spring Framework — framework selection & migrationdecisions
Libraries: Cloud Authentication SDK, Jackson, Lombok — library design & release ownership
Build Tools: Maven, npm, Artifactory, GitFlow Maven Plugin — release governance
CI/CD: Jenkins (strategy owner), GitHub Actions (architecture owner), SonarQube, Docker/Selenoid —infrastructure decisions
Reporting: Report Portal, Datadog — ecosystem strategy & alerting thresholds
AI Tools: Claude Code (platform architect), MCP (tool integration strategy), QE Standards Platform (20+skills)
Patterns: All P3 patterns + Configuration-as-Code, multi-repo architecture

Role Summary

The P4 Lead Quality Engineer defines the technical vision for Quality Engineering across the Identity domain. Theyarchitect platforms that entire teams build upon, make technology decisions that shape multi-year strategy, and driveorganizational effectiveness through tooling, standards, and process design. They operate at the intersection ofengineering, product, and organizational leadership — ensuring the QA team delivers maximum quality signal with minimumfriction. They are the technical authority on test architecture, the bridge to partner engineering teams, and the steward ofQA engineering culture.

Core Languages: Java (Architect — Framework & Library Design)

What's Expected:

Architect multi-module shared libraries consumed by 50+ engineers across teams (shared API library with 40+ serviceintegrations, custom exception hierarchy, versioned releases)
Define Java coding standards enforced via checkstyle, code review governance, and AI tooling
Design release engineering processes (GitFlow, semantic versioning, Artifactory publishing, weekly release cadence)
Make technology adoption decisions (Java version migration, record types, virtual threads, module system)
Design API client architecture patterns that scale to 40+ backend service integrations
Define exception hierarchies that enable intelligent retry vs fail-fast behavior across all consumers
Architect token management systems (concurrent profile tokens, background refresh scheduling, multi-tenant OAuth)
Drive dependency management strategy across modules with different Java version requirements

Practical Application:

Define the shared API library architecture:

Base class hierarchy ( AbstractRestApi → BaseApi → 40+ specialized clients)
Retry framework (configurable backoff, execution handlers, non-retriable exception classification)
Token lifecycle (concurrent token maps, background refresh interceptors, GraphQL refresh)
Connection management (pooling 100 total / 50 per route, eviction schedules)
Release process (GitFlow Maven plugin, Artifactory deploy, SNAPSHOT → release branch)
Define coding standards for the organization:
Google Java Style + team extensions (line length limits, specific naming patterns)
Checkstyle severity levels per module (error in libraries, warning in test code)
Member, method, parameter, and variable naming regex patterns
Drive architectural evolution decisions:
When to consolidate vs separate page objects (DOM overlap thresholds)
When to deprecate patterns (legacy prefixes, opportunistic rename policy)
When to introduce new patterns (records for DTOs, sealed interfaces for response types)

TypeScript (Architect — Platform Design)

What's Expected:

Architect shared npm packages consumed by multiple repos (shared Playwright infrastructure library)
Define TypeScript framework patterns for the organization (fixture composition, page object base, configmanagement)
Make framework selection decisions (Playwright over Cypress/WebdriverIO — rationale, migration planning)
Design internal package publishing strategy (internal npm registry, versioning, breaking change policies)
Define module boundaries across repositories (what lives in the shared infra library vs domain-specific repos)
Architect the configuration system (environment loading, locale YAML, encrypted secrets, path aliases)

Practical Application:

Design and maintain the shared Playwright infrastructure package:

BasePage
class all page objects extend
ConfigManager
with environment + locale YAML loading
AccountClient
for account CRUD
Fixture composition patterns (base → account → page)
Logger, encryption utilities, constants
Publishing to internal npm registry
Define the repository architecture:
Shared Playwright infrastructure — npm package consumed by all Playwright repos
Identity Smoke Tests — lightweight smoke testing suite for quick validation
Identity E2E Test Suite — comprehensive multi-client Identity testing (50+ specs, 10+ clients × 10+ regions)
Clean separation: shared code in infrastructure package, domain-specific tests in consuming repos

Drive technology decisions:

Playwright version adoption strategy (latest features, browser engine updates)
TypeScript strict mode enforcement across all repos
ESLint configuration and custom rule development
Node.js version policy
Shell / Infrastructure Scripting

What's Expected:

Build one-command setup systems (unified install: CLI tools, plugin configuration, shell integration)
Design configuration distribution mechanisms (symlink or copy-based deployment of shared standards)
Architect secrets management (centralized env files, auto-sourced at shell startup)
Build CLI tool ecosystems (bundled tool installations for the team)
Design developer experience workflows that minimize onboarding friction
Platform Architecture

QE Standards Platform (Owner)

What's Expected:

Architect the centralized standards enforcement platform (Claude Code rules and skills):
Rules system (auto-loaded coding standards for all governed repos)
Skills system (20+ AI-powered slash commands for team workflows)
Distribution model (symlink-based deployment, live updates)
Setup automation (one-command install for new team members)
Define and maintain coding standards consumed by 50+ engineers:
Style guide — Comprehensive Java/test coding conventions
XPath formatting — 16 rules for consistent locator formatting
JavaDoc standards — Generation settings for consistent documentation
Compound word naming — login/signup/logout/setup grammar rules
Test description naming — Feature - Scenario pattern
Architecture naming — Package plural, class singular, POM-to-test alignment
Design and build AI-powered QA workflows:
Test failure classification and automated reporting
Single failure investigation with evidence collection and Jira filing
Two-launch comparison (new failures, recovered, pass rate delta)
Pipeline triggering and monitoring
Template-compliant ticket creation across multiple Jira projects
Project planning structure with outlines and test plans
Standard-compliant PR creation and review workflows
QA priority inbox and team notifications
Design governance model:
CODEOWNERS for skill/module ownership
PR validation CI for checklist compliance
Reviewer auto-assignment based on modified modules

Multi-Repository Architecture (Owner)

What's Expected:

Define repository boundaries and responsibilities:

Repository
Purpose
Primary Consumers
Tech Stack
QE StandardsPlatform
Standards, AI skills, toolingconfig
All QE engineers
Shell, YAML,Markdown
Web AutomationFramework (Primary)
Core Selenium/TestNGframework + tests (Disney+ &ESPN+)
Identity, Commerce (billing &subscriptions), AppEx (browse& playback)
Java, Selenium,TestNG, Spring
Shared API Library
Backend API client library
All Java test repos
Java 17, Spring,GraphQL, Jackson
Shared PlaywrightInfrastructure
Playwright frameworkpackage
All Playwright test repos
TypeScript,Playwright
Identity Smoke Tests
Identity smoke testing inPlaywright
Identity team
TypeScript,Playwright
Identity E2E TestSuite
Comprehensive Identity E2Etesting

Identity team (all authenticationclients)

TypeScript,Playwright
Web AutomationFramework (Hulu)
Integration tests for Hulu
Commerce (billing &subscriptions), Account flows
Java, Selenium,TestNG, Spring
Design dependency flow and versioning strategy (standards platform distributes to all repos; shared API libraryconsumed by Java repos via Maven; shared Playwright infrastructure consumed by TypeScript repos via npm)
Make build-vs-buy decisions for shared infrastructure
Drive migration strategy (Selenium → Playwright for new features; maintain both during transition)
Define cross-repo consistency standards (naming, structure, CI/CD patterns)
Test Strategy & Architecture

Multi-Product Test Architecture (Strategist)

What's Expected:

Define how Identity testing spans across all streaming products:
Unified commerce module shared across all products
Product-specific page objects for unique UIs
Shared API client supporting all products via partner/brand configuration
Cross-product regression strategy
Design coverage models that balance breadth (locales × clients × states × products) with depth (happy path + edgecases):
10+ registered authentication clients × 10+ regions × N account states × M flows
Priority matrix determining which combinations run nightly vs weekly vs on-demand
Validated-specs manifests preventing untested code from running in CI
Architect the Customer User Journey (CUJ) framework:
15+ journey categories covering the Identity domain
Each journey expands across applicable client × region combinations
Clear ownership mapping (which journeys belong to which dev team)

Parallel Execution Strategy (Architect)

What's Expected:

Design parallel execution architecture across all frameworks:
Java/TestNG: ThreadLocal isolation, dynamic thread count from device availability, suite-level configuration
Playwright: Worker-based parallelism (4 CI workers, 2 local), serial describe blocks for stateful flows
Implement infrastructure-aware scaling:
Health checks determining available capacity
Dynamic thread count adjustment based on grid availability
Platform-specific device pools (smart TVs, mobile devices, tablets)
Define retry and stability strategies:
TestNG retry with custom analyzers (flaky vs real failure detection)
Playwright retry (1 in CI, 0 local)
API call retry with exponential backoff
Design result aggregation across distributed parallel runs

Test Data Architecture (Strategist)

What's Expected:

Define account management strategy across all repos:
Dynamic creation via API (preferred for isolation)
Pool-based pre-seeding for expensive account types (per client × region × state)
Persistent accounts for long-running scenarios
CAPTCHA-exempt test accounts for automated flows
Design cleanup and lifecycle management:
Automatic archival after test completion
Listener-based cleanup on failure (capture state before archival)
Pool replenishment strategies (lazy seeding, batch pre-creation)
Define secrets management for test credentials:
Centralized secrets file (auto-sourced at shell startup)
CI-specific secrets (GitHub Secrets, Jenkins Credentials)
Per-client account credentials for multi-role testing
Encryption for sensitive data in config files
CI/CD & Infrastructure Strategy

CI/CD Architecture (Owner)

What's Expected:

Define the CI/CD strategy across all repos:
Jenkins for Java/Selenium-based test repos (legacy, well-established)
GitHub Actions for Playwright repos (modern, containerized)
Hybrid approach during migration period
Design pipeline patterns:
PR validation: lint + typecheck + auto-detected regression scope
Nightly regression: full suite across all priority locales
Scheduled domain runs: account management 2x daily, profile/device management 2x daily, smoke 4x daily
On-demand: manual dispatch with configurable scope/platform/environment/locale
Architect infrastructure decisions:
Selenium grid infrastructure selection and capacity planning
GitHub hosted runners for Playwright execution
Artifact retention policies (14-day reports, 7-day traces)
Secrets rotation and management across pipelines

Release Engineering

What's Expected:

Own the shared API library release process:
Regular release cadence via GitFlow Maven plugin
Semantic versioning (SNAPSHOT → release)
Internal registry publishing with templated credentials
Breaking change communication to consuming teams
Version compatibility matrix across consuming modules
Define release governance:
PR requirements (unit tests, JavaDoc, static analysis)
Review requirements (impacted individuals, shared class owners)
Release notes and changelog management
Rollback procedures when releases break consumers
Reporting & Observability Strategy

Test Reporting Architecture (Owner)

What's Expected:

Define the test reporting ecosystem:
Report Portal for test execution results and failure analysis
Test management tools for test case management and requirement traceability
Grid management tools for Selenium session recording
Teams for real-time notifications and daily summaries
Datadog for infrastructure monitoring and alerting
Design automated triage workflows:
AI-powered failure classification
Automatic Jira ticket creation for confirmed bugs
Adaptive Card notifications to Teams with actionable links
Health check dashboards showing pass rate trends
Build comparison and trend analysis:
Launch-to-launch comparison (new failures, recovered, consistent)
Branch vs main regression detection
Pass rate trend monitoring with alerting thresholds
AI & Automation Strategy
AI-Augmented Q

A Platform (Visionary)

What's Expected:

Define the AI strategy for Quality Engineering:

Claude Code as the AI backbone with custom skills and rules
QE Standards Platform as the distribution mechanism for AI-powered workflows
MCP (Model Context Protocol) for tool integration (Report Portal, Playwright, Jenkins)
Self-healing test infrastructure triggered by AI analysis on failure
Design the skill ecosystem:
20+ slash commands covering common QA workflows
Shared configuration (launch relevance, messaging templates)
Evaluation framework for skill quality and accuracy
Governance model for skill ownership
Drive technology evaluation:
AI browser automation comparison (traditional Playwright vs AI-driven approaches)
Cost/benefit analysis of AI test generation vs manual test writing
MCP server development for custom tool integrations
Framework migration planning (documented comparisons and roadmaps)
Build team capability:
Train team on effective AI tool usage
Define guidelines for AI code review (what to accept vs what to override)
Establish AI output validation standards

Organizational Leadership Team Structure & Growth

What's Expected:

Define team structure and responsibility boundaries:
Identity team scope — signin, profiles, device management, family/parental controls, privacy consent
Commerce team scope — billing, subscriptions, plan management
Cross-team shared infrastructure ownership
Design hiring requirements and interview processes:
P1-P4 skill expectations (this document)
Technical assessment criteria per level
Domain knowledge ramp-up expectations
Drive career development:
Define growth paths from P1 → P4
Identify skill gaps and training opportunities
Create stretch assignments that build senior skills
Mentor P3 engineers toward architectural thinking

Cross-Team Technical Leadership

What's Expected:

Represent QA in architecture discussions with development teams
Drive testability requirements in new feature design:
Stable data-testid attributes in UI components
API contracts that enable test data setup
Feature flag integration for test isolation
Environment parity between QA and production
Define quality gates and release criteria:
PR requirements per repository (JIRA ticket, description, static analysis, test evidence)
Regression pass rate thresholds before release
Required locale coverage before production deployment
Build relationships with platform teams:
Negotiate grid capacity and infrastructure SLAs
Align on deployment schedules that enable QA
Drive test infrastructure reliability requirements
Standards & Governance
What's Expected:
Define and enforce coding standards across the organization:
Naming conventions (compound words, test descriptions, package/class alignment)
Formatting standards (XPath, assertions, annotations, line length)
Architectural patterns (POM hierarchy, data providers, API-first setup)
Documentation requirements (JavaDoc, class-level docs, PR templates)
Design enforcement mechanisms:
Checkstyle configurations per module
ESLint rules for TypeScript repos
CI gates (lint, typecheck, PR checklist validation)
AI-powered review via QE Standards Platform skills
CODEOWNERS for critical path code
Balance standardization with pragmatism:
When to enforce strictly vs allow exceptions
When to migrate gradually vs rewrite
When standards apply (new code) vs legacy exceptions (existing code)
How to evolve standards without breaking existing patterns

Project Management

What's Expected:

Define Jira project structure:

Identity project: planned QAA work (Epics, Tasks)
Cross-team project: Commerce (billing & subscriptions)/cross-team work (Epics, Tasks)
Bug project: Defects found during testing (filed against dev teams)

Design workflow templates:

Task description templates (Description/AC, Notes, Affected Repos, Dependencies)
Bug description templates (Summary/Repro Steps, Evidence/Debug Info, Affected Pages, Related Tickets)
Component assignments and label conventions
Drive project planning methodology:
Planning folder structure per project
Outline → test plan → Jira tickets → execution workflow
Archive completed projects
Technology Evaluation & Decision-Making

Framework Selection

What's Expected:

Evaluate and select testing frameworks for new initiatives:
Playwright for new browser automation (over Cypress, WebdriverIO, Selenium)
TestNG for Java test execution (over JUnit)
Spring RestTemplate for API clients (over OkHttp, Apache HttpClient)
Jackson for JSON serialization (over Gson)

Document decision rationale:

Selection criteria (performance, maintainability, team expertise, ecosystem)
Migration cost vs benefit analysis
Coexistence strategy during transition periods
Sunset timeline for deprecated technologies
Drive migration planning:
Selenium → Playwright for new features (maintain Selenium for legacy)
Legacy → modern framework consolidation
Java version upgrades across modules
Infrastructure & Tooling Decisions

What's Expected:

Evaluate and adopt QA infrastructure:

Selenium grid solutions for browser automation
Report Portal for test result management
Cloud testing providers for cross-browser validation
Monitoring tools for infrastructure health
CLI tool distribution platforms
Design developer experience:
One-command setup for new team members
IDE configuration templates (IntelliJ, VS Code)
Documentation-as-code for evolving standards
AI-powered workflows that reduce manual toil
What Success Looks Like at P4

Platform & Architecture

The QA platform you've architected — standards, shared frameworks, and CI/CD — measurably accelerates teamvelocity
Test architecture scales to 10+ clients × 10+ regions × N account states without exponential complexity growth
The shared API library is the trusted foundation for all API-based testing across the organization
Team Enablement
New engineers at any level become productive within days, enabled by setup automation and clear documentation
Junior engineers consistently grow into senior engineers through your mentoring and deliberate growth paths
Code quality remains high because standards are clear, enforceable, and pragmatically applied
Tooling & Automation
The AI-powered workflow system (20+ skills) saves hours daily on triage, reporting, and ticket management
Quality signal is reliable: passing tests mean the release is safe; failures are actionable, not noisy
Organizational Impact
Dev teams design features for testability from the start — not as an afterthought
You've built a QA engineering culture where the team ships quality at speed, not quality despite speed

Apply now »