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.
RequirementsAPI
& 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)