Principal Backend Engineer

Data2; Seattle (WA); On-site; USD 80,000 - 110,000; Full time

Job summary

Data2 is seeking a Backend Test Engineer in Seattle, United States, to develop and execute automated tests for FastAPI services. The role focuses on backend testing, integration validation, and CI/CD pipeline integration. Candidates should have experience in testing microservices with production-quality Python, utilizing frameworks like pytest. Experience in Kubernetes environments and graph databases like Neo4j is preferred. This position involves collaboration with engineering teams to ensure data and service quality.

Qualifications

• Experience testing backend systems (APIs, microservices).
• Comfortable reading and writing production-quality Python (not just test scripts).
• Experience with pytest or similar frameworks.

Responsibilities

• Design and maintain automated tests for FastAPI services.
• Validate request/response schemas, error handling, and auth flows.
• Ensure consistency of data across services.

Skills

Experience testing backend systems

Production-quality Python

pytest or similar frameworks

Designing integration tests

Working with CI/CD pipelines

Strong English skills

Tools

FastAPI

Kubernetes

Neo4j

Memgraph

Job description

Seattle, United States | Posted on 04/28/2026

From disconnected data to confident, explainable decisions

data² delivers trustworthy, explainable AI (eXAI) that automates critical workflows and turns complexity into clarity. Our patented, hallucination-resistant eXAI reView platform harmonizes data across your ecosystem delivering real-time actionable insights.

Job Description

reView is a microservices backend over a graph data layer. Correctness in our system depends not just on API behavior, but on whether data is correctly structured, linked, and query‑able across services. In a regulated‑industry product, the difference between a result that runs and a result that is right is the entire value of the platform.

Scope

• Backend and data‑focused testing (not UI‑heavy)
• Integration and workflow correctness over broad end‑to‑end coverage
• Deeper performance and full‑system validation evolve over time
• Embedded with the platform team, pairing closely with backend engineers
• Local and test environments are containerized (Docker‑based), with shared staging for integration validation

Leveling: At the mid level, you will execute and extend an evolving test strategy. At the senior level, you will shape that strategy and influence how the platform is built for testability.

Requirements

API & Service Quality (Primary)

• Design and maintain automated tests for FastAPI services
• Validate request/response schemas, error handling, and auth flows
• Write tests across layers: unit tests (targeted handler‑level validation), integration tests (service‑level using test environments), and API‑level smoketests against running services
• Prevent regressions across service boundaries

Integration & Workflow Testing (Primary)

• Validate behavior under realistic conditions (retries, partial failures, async flows)
• Ensure consistency of data across services

Data & Graph Validation (Targeted but Important)

• Verify correctness of node and relationship creation in Neo4j / Memgraph
• Validate key queries and multi‑hop traversals against expected outputs
• Detect issues such as missing or incorrect relationships, duplicate entities, broken identity assumptions, and incorrect mappings during ingestion
• Define and evolve the approach to graph test fixtures (data seeding, isolation, repeatability)

End‑to‑End & Smoke Testing (Selective)

• Implement a small number of high‑value end‑to‑end or API‑level tests
• Focus on critical workflows rather than broad UI coverage
• Use pragmatic approaches (e.g., pytest‑driven flows, containerized environments)

CI/CD & Quality Gates

• Integrate test suites into CI pipelines
• Define and enforce quality gates for merges and releases (coverage thresholds, integration test pass rates, graph‑integrity checks)
• Maintain test reliability and reduce flakiness

Performance & Reliability (Shared)

• Run basic load and stress tests using standard tooling – e.g., recurring load tests to catch regressions in core ingestion and query paths
• Identify obvious bottlenecks in APIs and graph queries
• Collaborate with engineers on scaling behavior in Kubernetes

Debugging & Observability (Shared)

• Trace issues across services and data layers
• Help reproduce production issues locally and in test environments

Required

• Experience testing backend systems (APIs, microservices)
• Comfortable reading and writing production‑quality Python (not just test scripts)
• Experience with pytest or similar frameworks
• Experience designing integration tests across services
• Experience working with CI/CD pipelines
• Comfortable working in systems where requirements are incomplete and tests help define expected behavior
• Strong written and spoken English skills for cross‑border collaboration

Preferred (Not Required)

• Experience with FastAPI or similar Python frameworks
• Experience working in Kubernetes or distributed systems
• Experience testing data pipelines or ETL workflows
• Familiarity with graph or query‑based systems (e.g., Neo4j, Memgraph, SQL, Cypher)