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

Vista previa de la oferta

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

lead · Technology / Software Development

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