QA Engineer

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 queryable 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. Concrete examples of what that means in practice:

• Did the right nodes and relationships get created across multiple services?
• Does a multi-step query return the correct result, not just a plausible one?
• Are data integrity guarantees holding under realistic load and failure conditions? If testing API contracts and data integrity across a graph sounds interesting, this role is designed for that. 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 smoke tests against running services

Prevent regressions across service boundaries

Integration & Workflow Testing (Primary) Build tests for critical flows (e.g., ingestion â graph â query â result)

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) Use logs and dashboards (Grafana + Loki) to investigate failures

Trace issues across services and data layers

Help reproduce production issues locally and in test environments

Qualifications 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)

Exposure to load testing tools (any)