Quality Assurance Engineer II

The Data Pipeline team is a backend-focused engineering team that cares deeply about quality and reliability. We believe in autonomy, we trust data, and we own what we ship end-to-end. We move our customers' data in and out of Bloomreach Engagement reliably and at a high rate:

• Our clients feed their visitors' behavior through real-time tracking to our platform. The data then can be analyzed and used for marketing automation. We process tens of thousands of requests per second.
• Imports are critical for our clients to utilize our platform to the fullest. We import millions of rows of data and continuously improve the throughput and reliability of our imports and integrations with other data storages.
• We are also responsible for exporting data from our platform to Google's BigQuery using Google's DataFlows, PySpark and Apache Beam, allowing data access by our clients.
• We run and support our services in production, handling high-volume traffic using Google Cloud Platform and Kubernetes.

Every one of these flows is something our customers rely on being correct, at scale. That is the terrain your testing and automation will cover.

You won't be doing this alone: you'll join an experienced Senior Quality Engineer already on the team, so you'll have a buddy to ramp up with, bounce ideas off, and share the quality mission with from day one. We work remotely first (from Central & Eastern Europe), but we are more than happy to meet you in our nice offices in Bratislava, Brno or Prague. And if you are interested in who will be your engineering manager, check out Adam's LinkedIn.

Intrigued? Read on 🙂 ...

As a Quality Engineer in Data Pipeline, you own quality for systems that move huge volumes of customers' data in real time, at scale, across many integrations. This is a backend, data-heavy world: a tracking API on one side, an internal message format and multiple storages on the other, with Kafka, GCP and Kubernetes in between. Guaranteeing quality here means understanding how data flows end-to-end and where it can go wrong.

We need you to bring engineering rigor to that quality. Concretely, you will:

• Own end-to-end and integration testing. Complex data pipelines can behave correctly component by component yet still surprise you end-to-end. You design the tests that validate real behavior across components, so we can ship changes to high-scale integrations with confidence.
• Build automation that runs repeatedly in CI. Turn testing into automated integration and end-to-end suites (e.g. Robot Framework, API tests) wired into the deployment pipeline, giving engineers fast, reliable feedback on every change.
• Go deep in the imports domain. Imports are a rich, well-defined area with plenty to reason about. You'll build deep context so you can proactively tell the team what to test, how, and why, and where the edge cases hide.
• Shift left. Be part of grooming and design from day one, thinking about test cases and failure modes while features are being shaped rather than after the fact.
• Strengthen the pipeline core too. Beyond imports, help raise quality across the Data Pipeline core as you grow context.
• Partner with the developers. Quality is a shared responsibility: developers own their in-source tests and you add the outside-in automation layer and perspective. You make the whole team better at testing, not the place work gets handed off to.

• Design and own black-box, API-level and integration/end-to-end test automation for Data Pipeline services, primarily in the imports domain.
• Build and maintain automated test suites in CI/CD (GitLab) that gate deployments and catch regressions across components.
• Read Go/Python pipeline code well enough to find holes and design meaningful test cases - you don't need to ship features, you need to understand the system.
• Drive test strategy in grooming and design reviews - test types on the ticket, acceptance criteria, edge cases, failure modes.
• Pair with our current Data Pipeline QA to spread automation and code-adjacent testing practices across the team.
• Use telemetry and reproduction to turn production incidents into durable, automated regression tests.

• Languages: Python (primary), Go (enough to read pipeline code)
• Test automation: Robot Framework (API/integration and Browser-based E2E), CI-driven suites in GitLab, with ReportPortal / Allure reporting
• Platform you'll test against: Apache Kafka, Google Cloud Platform, Kubernetes, BigQuery, MongoDB, Redis
• CI/CD & tooling: GitLab, Jira, Confluence
• AI coding agents: Cursor, Claude Code, ...
• ... and much more 🙂

Must have

• You write test automation in code - integration and API tests in CI, in Python / Go or a similar language.
• You can read backend/pipeline code (Go or Python) well enough to find gaps and reason about where a change can break something else. Useful QA sees the cross-component failure the feature author might missed.
• You are comfortable owning black-box, API and integration/end-to-end automation - the outside-in layer. (In-source unit and in-repo integration tests remain with the feature developers.)
• You want to work primarily in code and automation. If you are coming from a mostly manual testing background, that is fine - as long as you are excited to make automation your main craft, because that is where this role lives.
• You are comfortable in grooming and design from day one - a shift-left mindset, defining test types and cases on the ticket before code is written.
• You can learn and adapt - essential when navigating a large codebase and a data domain that mixes tracking, imports, and multiple storages.
• You know how to be effective in a remote-first environment.
• Fluent use of AI coding agents (Cursor, Claude Code, Copilot, Gemini CLI, or similar) as part of your daily workflow.

Strongly preferred

• Prior backend exposure (an internship or role where you wrote code, or worked under a senior who set up proper testing/automation workflows) - it makes the pipeline world far less of a black box.
• Experience with ETL / data-pipeline testing: connectors, ingest at scale, data cleanup and transformations, and validating data landing correctly in target storages.
• Experience testing systems built on Kafka, GCP, or BigQuery.
• Familiarity with test frameworks such as Robot Framework, Playwright or API testing tooling (Postman and beyond).

Personal qualities

• Ownership - you take quality from detection through to a durable, automated fix that prevents the next regression.
• Systematic thinking - you find root causes, not symptoms, and you document what you learn so the team levels up.
• Collaboration - you make developers better at testing rather than becoming the place work gets "thrown over the wall".
• Curiosity - you enjoy peeling back a data pipeline until you understand what can go wrong and why.

In 30 days

• Get to know the Data Pipeline team, the company, and the most important processes.
• Set up your local and cloud development environment and complete the Engagement engineering onboarding.
• Understand how our pipelines work end-to-end - tracking, imports, exports - and how we approach testing and automation, with a focus on the imports domain.

In 90 days

• Deliver your first meaningful quality improvement: an automated integration or end-to-end suite for a real imports flow, wired into CI so it gates deployments.
• Be active in grooming and design reviews, defining test cases and surfacing edge cases and cross-component risks before implementation.
• Pair with our current QA to share automation practices and broaden the team's quality coverage.

In 180 days

• Own the quality posture of the imports domain end-to-end - the team relies on your suites and your judgment on what "tested" means.
• Drive measurable improvements: more of the pipeline covered by repeatable automated tests, faster feedback in CI, and higher release confidence across the team.
• Extend your coverage and influence into the Data Pipeline core.
• Find out that our values are truly lived by us. We are dreamers and builders. Join us!

#LI-KP1