Senior Test Automation Engineer – UI, API & .NET

Position: Senior Test Automation Engineer – UI, API & .NET
Company: Global Airline Manufacture
Location: Seattle, Washington, USA
Work Arrangement: Onsite x4 days a week Friday remote
Employment Type: C2C OK. Must be US Citizen or Green Card. No Visa. Contract to Hire.
Start Date: Immediate Availability
Background Check: Mandatory
Primary Technologies: Playwright, Cypress, .NET, C#, NUnit, JavaScript, REST APIs, Azure DevOps, Jenkins, GitHub Actions, Git, and AI-Assisted Testing

Overview
The Senior Test Automation Engineer will design, build, implement, and maintain comprehensive automated testing solutions covering user interfaces, REST APIs, and supporting data layers. The primary performance challenge is to create reliable, maintainable automation frameworks that improve test coverage, accelerate defect identification, and support consistent software delivery.
This is a hands-on engineering role requiring demonstrated experience developing automation frameworks from scratch rather than relying exclusively on existing test suites. The engineer will use Playwright or Cypress for UI automation, .NET/C# with NUnit for API automation, and appropriate validation techniques to test functionality and content across application layers.
The position also requires experience integrating automation into CI/CD pipelines using Azure DevOps, Jenkins, or GitHub Actions. The engineer will configure test execution using dotnet, implement NUnit/TRX reporting, support environment-specific configuration and parallel execution, and maintain automated test code through disciplined Git branching, pull requests, and code reviews.
The engineer will operate in an Agile/Scrum environment and use approved AI tools to accelerate test development, improve script stability, and support debugging and analysis.

Purpose: Build the automated quality-engineering capabilities that help development teams deliver dependable software. Your work will strengthen confidence in application functionality, API behavior, and content accuracy by providing reliable automated validation across multiple technology layers.

Motivators: This opportunity is well suited to an engineer who enjoys writing code, designing frameworks, troubleshooting difficult automation problems, and improving software quality through practical engineering solutions. The position offers meaningful technical ownership, visible delivery outcomes, and the opportunity to combine Playwright or Cypress, C#/NUnit, CI/CD, and AI-assisted testing into a cohesive automation capability.

Requirements

- UI Automation Engineering: Strong hands-on experience developing and maintaining UI automation using Playwright or Cypress. Candidates should demonstrate the ability to write reliable tests, troubleshoot failures, and structure automation for long-term maintainability.

- API Automation with .NET/C# and NUnit: Demonstrated experience writing API automation using .NET/C# with NUnit, including REST API testing, HTTP status-code validation, response-content validation, and debugging API failures.

- Framework Development: Proven ability to design and build automation frameworks from scratch, including reusable components, test organization, configuration management, reporting, and maintainable test architecture.

- Programming Capability: Strong practical programming skills in C# and/or JavaScript, with sufficient C# proficiency to implement the required .NET/NUnit API automation.

- End-to-End Test Strategy: Experience designing testing approaches that cover UI, API, and data layers, including the selection of appropriate validation techniques and management of cross-layer dependencies.

- Content Validation and Test Isolation: Hands-on experience using API-based content validation, mocked UI behavior, and stubbed services to validate functionality or isolate dependencies.

- CI/CD Integration: Experience integrating automated testing into Azure DevOps, Jenkins, or GitHub Actions, including dotnet test execution, NUnit/TRX reporting, environment configuration, and parallel execution.

- Source Control and Collaboration: Strong working knowledge of Git branching, pull requests, code reviews, and collaborative automation development.

- AI-Assisted Testing: Practical experience using AI tools to accelerate test development, improve script stability, and assist with debugging and analysis while independently validating results.

- Agile/Scrum Delivery: Ability to contribute effectively within Agile/Scrum teams, coordinate testing with development activities, and maintain automation as application functionality changes.

- Worksite and Screening Requirements: Availability to work onsite in Seattle, Washington, ability to meet the immediate-start requirement, and completion of the mandatory background check.

Objectives
1. Design and Establish a Maintainable End-to-End Automation Framework. Within the first 30–90 days, assess the existing application architecture, testing requirements, automation assets, and available development environments to define an integrated automation approach covering UI, API, and relevant data layers. Design and implement or materially enhance a reusable framework using Playwright or Cypress for UI automation and .NET/C# with NUnit for API automation. Success will be measured by a functioning framework, successful execution of representative automated tests, demonstrated reuse of common components, and acceptance of the framework approach by relevant engineering stakeholders.

2. Deliver Reliable UI, API, and Content Validation Coverage. Within the first 60–120 days, develop automated test suites that validate priority application workflows, REST API behavior, and relevant content or data outcomes. Use Playwright or Cypress to validate UI functionality, .NET/C# with NUnit to test API endpoints and responses, and API-based validation or mocked UI and stubbed services where these approaches provide effective test isolation. Success will be measured by automated coverage of agreed priority scenarios, successful detection of intentionally introduced or known defects, accurate validation results, and reduced dependence on manual regression execution.

3. Integrate Automation into CI/CD and Improve Execution Reliability. Within the first 90–150 days, integrate the automated test framework into the organization's selected CI/CD platform, such as Azure DevOps, Jenkins, or GitHub Actions. Configure repeatable test execution using dotnet, appropriate NUnit/TRX reporting, environment-specific settings, and parallel execution where supported. Success will be measured by successful unattended pipeline execution, accessible test reports, repeatable execution across agreed environments, and a documented reduction in avoidable test failures or execution delays.

4. Strengthen Agile Quality Engineering Through Automation and AI-Assisted Improvement. Within the first 90–180 days, establish an effective approach for developing, maintaining, reviewing, and improving automation as part of the Agile/Scrum delivery process. Collaborate with relevant engineering and quality stakeholders to prioritize automation work, identify gaps in test coverage, troubleshoot defects, and ensure test results support timely release decisions. Success will be measured by timely automation delivery, improved test maintainability, actionable defect findings, and measurable improvements in automation development or troubleshooting efficiency.

Critical Subtasks
1. Assess the Application and Define the Automation Strategy. During the first 15–30 days, review the application's major workflows, REST APIs, data dependencies, current testing approach, development practices, and available automation assets. Identify priority end-to-end scenarios, testability constraints, environment requirements, and opportunities for API-based validation, mocked UI testing, or stubbed services. Develop an initial automation strategy that defines the scope of UI, API, and data-layer coverage and identifies the framework components required for reliable execution. Success will be measured by an agreed automation approach, a prioritized set of test scenarios, and clear technical requirements for framework implementation.

2. Build the Core Automation Framework. During the first 30–60 days, create or enhance the foundational automation architecture using Playwright or Cypress and .NET/C# with NUnit. Implement reusable test components, test data handling, environment configuration, execution conventions, and appropriate framework structure to support ongoing expansion. Maintain framework code through Git branching, pull requests, and code reviews while documenting the steps required for other engineers to execute and contribute tests. Success will be measured by successful execution of initial UI and API tests, reusable framework components, and a maintainable codebase suitable for team adoption.

3. Develop API Automation and Content Validation. During the first 45–90 days, implement automated REST API tests using .NET/C# and NUnit to validate endpoints, HTTP status codes, response structures, content, and relevant business rules. Develop API-based validation techniques that verify application data and content independently of the user interface when appropriate. Use stubbed services or other controlled test dependencies where necessary to isolate functionality and improve diagnostic accuracy. Success will be measured by automated coverage of agreed API scenarios, accurate validation results, and the ability to identify and diagnose representative API or content defects.

4. Implement UI and Cross-Layer End-to-End Testing. During the first 60–120 days, develop Playwright or Cypress tests covering priority user journeys and application interactions. Connect UI validation with API and relevant data-layer checks to confirm that critical workflows produce the expected results across system boundaries. Apply appropriate synchronization, test isolation, reusable selectors, and stable data-handling practices to reduce avoidable test failures. Success will be measured by successful execution of agreed end-to-end scenarios, reliable cross-layer validation, and improved stability of the automated UI test suite.

5. Integrate Automated Testing into CI/CD Pipelines. During the first 90–150 days, configure automated test execution within the organization's selected Azure DevOps, Jenkins, or GitHub Actions environment. Implement dotnet-based test execution, NUnit/TRX reporting, environment-specific configuration, and parallel execution where technically appropriate. Ensure pipeline failures provide useful diagnostic information and that test results are available to relevant engineering stakeholders. Success will be measured by successful unattended pipeline execution, reliable test reporting, and repeatable validation of application changes through the delivery workflow.