re View 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)

📌 QA Engineer (León)
🏢 Data Squared
📍 León