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)