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)

📌 QA Engineer (Saltillo)
🏢 Data Squared
📍 Saltillo