Principal, Quality Engineering

About DawerOne

DawerOne is a senior-led engineering partner to North American companies. We lead product and engineering transformations and deliver them ourselves, from architecture to production. Our engineering team is in Gurugram.

We are building a quality engineering capability that goes beyond conventional QA: automated test infrastructure, CI/CD integration, environment provisioning, reliable test execution, AI-powered testing agents, and continuous evaluation of AI-enabled applications. We want quality to be an engineered property of the delivery lifecycle, not a phase that happens after development.

The role

We are looking for a Principal, Quality Engineering who can architect, build, and operationalize modern quality engineering systems across client engagements. This is a hands-on technical leadership role: you define the architecture and implement the engineering behind automated testing, quality gates, test infrastructure, and AI-enabled quality workflows.

You will work directly with the client's engineering leadership (VP of Engineering, CTO, or CIO), project sponsors, and C-level stakeholders from week one, and with their developers, platform engineers, and product teams, to establish the target architecture, implement the highest-impact improvements, and demonstrate measurable results. Alongside client delivery, you will build DawerOne's reusable quality engineering platform and apply it across subsequent engagements.

We are looking for an engineer who can move from an architecture diagram to working code, from a pipeline design to a production implementation, and from an AI testing prototype to a controlled, measurable engineering workflow.

What you'll own

1. Quality engineering architecture

• Define a layered test architecture spanning unit, component, API, contract, integration, UI, end-to-end, performance, and AI evaluation testing, with boundaries, ownership, execution frequency, and quality gates for each layer.
• Set standards for deterministic execution, isolation, retries, cleanup, and reproducibility; design parallel execution, sharding, and caching.
• Establish measurable baselines for coverage, flakiness, execution time, escaped defects, and release confidence.
• Evaluate an existing test architecture, find its structural weaknesses, and implement a better one.

2. Test automation frameworks

• UI: Playwright and TypeScript with robust locators, reusable page and component abstractions, fixtures, authentication and role-based execution, trace capture, flaky-test quarantine, and API-based setup and teardown.
• API and services: REST and, where applicable, GraphQL and event-driven interfaces; schema validation, negative and authorization testing, contract testing, service virtualization, and asynchronous workflows.
• Data and integration: database assertions, transactional consistency, cross-service data flows, and invariant checks for critical business workflows.
• Treat test code as production code: linting, type checking, code review, and retirement of tests that no longer give signal.

3. CI/CD pipelines and quality gates

• Design, implement, debug, and maintain the testing pipelines yourself, on GitHub Actions, GitLab CI, Jenkins, Azure DevOps, or whatever the client runs.
• Decide which tests run at each stage based on risk, duration, and feedback value; integrate linting, static analysis, security checks, contract tests, smoke tests, and regression suites.
• Establish quality gates on explicit policies, not a single pass percentage, that block releases when critical criteria fail.
• Handle artifacts, secrets, result publishing, and failure notifications; optimize duration with parallelism and selective execution; build pipeline templates other teams can adopt.

4. Test infrastructure and environments

• Provision test infrastructure with the client's cloud and infrastructure-as-code tools (Terraform, OpenTofu, or cloud-native); containerized runners with Docker and, where justified, Kubernetes.
• Secure configuration and secrets, health checks and preflight validation, isolated environments for parallel runs, and service virtualization when dependencies are unstable or unavailable.
• Know which tests need local or containerized execution, shared integration environments, ephemeral environments, dedicated staging, or production-safe smoke tests.
• Build the smallest reliable system that gives the required coverage and feedback speed.

5. Test data engineering

• Build reusable test data factories and API-driven creation and cleanup; deterministic datasets for regression; unique data allocation for parallel execution.
• Design seeding, snapshot, and synthetic data strategies, with expiry so artifacts do not accumulate.
• Account for tenant isolation and role-based permissions; protect sensitive data through masking and access restrictions.
• Make failures reproducible by preserving data identifiers and execution metadata. Test data is an engineering dependency, not something engineers arrange by hand.

6. AI testing agents

• Design, build, and operate AI agents that execute bounded quality engineering tasks: test planning and generation from stories and API specs, coverage gap analysis, exploratory browser workflows, failure classification from traces and logs, proposed repairs when selectors change, and defect reports with reproducible steps.
• Engineer them properly: structured tool schemas (MCP or equivalent), execution limits, checkpoints, bounded retries, and least-privilege access.
• Require human approval for destructive actions; trace tool calls, prompts, model versions, and cost.
• Verify that an agent's claimed actions actually happened. A generated test is not automatically a correct test.

7. LLM evaluation and AI application reliability

• Build repeatable evaluation harnesses for LLM-powered features and agents: representative datasets, golden examples, edge cases, adversarial inputs, and regression suites.
• Evaluate correctness, instruction adherence, structured-output validity, tool selection and sequencing, retrieval grounding, and behavior when information is unavailable; test prompt injection, data leakage, and unsafe tool invocation.
• Use deterministic assertions where possible and rubric or model-based grading where not, validated against human-reviewed examples.
• Run regressions whenever prompts, models, retrieval, or tools change; track versions, set acceptance thresholds, and measure latency, token cost, and failure rate.
• Integrate the evaluations into CI/CD and release qualification.

8. Test observability and failure analysis

• Explain not only whether a test failed but why, with evidence: standardized result formats and metadata; logs, traces, screenshots, and API responses correlated with versions, commits, deployments, and dependency health.
• Classify every failure as product defect, test defect, infrastructure, environment, or external dependency; automate triage and deduplication.
• Detect flaky tests from execution history and produce dashboards that distinguish execution volume from actual quality outcomes.
• AI-assisted analysis produces evidence-linked hypotheses, not unsupported root-cause claims.

9. Performance, resilience, and security testing

• Design performance scenarios around realistic business workflows (load, stress, endurance, capacity) with baselines and regression thresholds integrated into the pipeline.
• Test resilience to dependency failures, timeouts, and partial degradation.
• Work with security and platform teams on authorization boundaries, tenant isolation, session handling, and sensitive-data exposure; ensure test agents and automation infrastructure cannot reach unauthorized environments or credentials.
• You do not need to be the sole specialist in each discipline; you must be able to architect the strategy and implement the appropriate checks.

10. Technical leadership and client alignment

• Align with the client's VP of Engineering, CTO, or CIO and project sponsors from week one on priorities, deliverables, and how progress is reported.
• Present the quality roadmap and communicate progress, risks, and measurable outcomes to client leadership, including when a release should not proceed.
• Review architecture and automation code; set repository structure and engineering conventions; make architectural trade-offs explicit.
• Mentor automation engineers, help developers own quality in their own workflows, and ensure testability is part of system design.

11. DawerOne's reusable quality engineering capability

• Each engagement should make the next one faster.
• Convert proven solutions into reusable assets: versioned, tested, documented repositories, libraries, framework components, pipeline templates, AI testing agents, and evaluation harnesses, with runbooks.
• Keep a clear boundary between DawerOne's reusable intellectual property and client-owned code and data.
• Feed real delivery experience back into these assets.

What success looks like

First 30 days: assess and architect

• Map the current test architecture, repositories, pipelines, environments, and dependencies.
• Assess reliability, duration, coverage, and failure patterns; identify gaps in test data, environments, and CI/CD.
• Agree a prioritized implementation plan with owners, deliverables, and measurable baselines, presented to the client's engineering leadership and sponsors.

Days 31 to 60: build and integrate

• Implement or improve the highest-priority frameworks and pipelines.
• Establish repeatable environment and test data mechanisms; integrate quality gates into development and release workflows.
• Implement initial observability and failure classification.
• Build a focused AI-assisted testing or LLM evaluation workflow where the application justifies it.

Days 61 to 90: demonstrate and operationalize

• Demonstrate reliable, repeatable automated execution with actionable failure reporting.
• Show measurable improvement against the agreed baselines.
• Document the architecture, operating procedures, and ownership.
• Package reusable components for future DawerOne engagements.

Exact milestones are agreed based on the starting environment and scope. Across subsequent engagements, you reuse and improve these assets, expand the AI testing and evaluation capabilities, and strengthen DawerOne's engineering standards and delivery methodology.

Required experience

Core engineering

• 15+ years in software engineering, quality engineering, or test automation.
• Architected and implemented production-grade automation frameworks, and write maintainable, modular, typed automation code.
• Strong hands-on expertise with Playwright and TypeScript; strong API and integration testing experience.

CI/CD and infrastructure

• Implemented CI/CD pipelines hands-on on GitHub Actions, GitLab CI, Jenkins, or Azure DevOps, and run automated tests in containerized environments.
• Working knowledge of Docker, secrets management, infrastructure as code, cloud networking, identity and access management, and environment isolation.
• Optimized parallel execution and diagnosed infrastructure-related failures.

AI and LLM engineering

• Integrated LLMs into engineering workflows or AI-powered applications, and built tool-using agents or agentic workflows; familiar with MCP or equivalent protocols.
• Designed evaluation datasets and repeatable LLM evaluation workflows, and can separate deterministic tests from probabilistic evaluations.
• Understand prompt injection, least-privilege tool access, sensitive-data handling, and AI system observability.

Technical leadership

• Established engineering standards and led technical implementation across multiple teams and senior client stakeholders.
• Diagnosed underperforming automation programs and delivered practical improvements.
• Strong written communication and documentation; able to work independently in an unfamiliar environment and deliver measurable results within a defined engagement.

Preferred experience

We value demonstrated implementation over familiarity with a long list of tools. Experience in several of these is valuable:

• Python for automation tooling and evaluation infrastructure; SQL and relational database testing.
• GraphQL, OpenAPI, and contract-testing frameworks; event-driven systems and queues.
• Terraform, OpenTofu, Kubernetes, and cloud-native infrastructure; observability platforms and structured logging.
• Performance testing tools such as k6 or equivalent.
• LLM evaluation frameworks, RAG and vector-search evaluation, agent orchestration frameworks, and browser automation driven by AI agents.
• Security testing, identity boundaries, and authorization validation.
• Enterprise platforms such as Salesforce, MuleSoft, Flowable, or Formstack.

Working arrangement

• Full-time, remote within India. Our team is in Gurugram; the half-day case study and technical assessment in the interview process is in person at our Gurugram office.
• Working hours 1:30 PM to 10:30 PM IST to collaborate with North American clients.
• Direct collaboration with client engineering leadership and technical teams; travel to client sites, including the United States, as needed.

Why join DawerOne

• Build production-grade engineering systems rather than stop at recommendations.
• Work at the intersection of quality engineering, infrastructure automation, and AI, on real delivery problems for North American clients.
• Influence technical architecture and implementation directly, and develop reusable capabilities that compound across engagements.
• Shape the engineering practices of a senior-led firm where senior people still write code.