About GetReal Security

As the world’s leading authority on the authentication and verification of digital media, we exist to protect enterprises, governments, and media from AI-powered deception, deepfake fraud, and identity manipulation — because trust in digital content is no longer guaranteed.

We bring together a unique blend of multi-disciplinary domain expertise to protect organizations from a new generation of attack vectors and rebuild trust in digital communications. We move fast, debate hard, and hold each other to a high bar — and we’re looking for a Senior Test Automation Engineer who thinks in data, builds in systems, and treats quality like an engineering problem worth solving properly.

This Is Not That Kind of Test Engineering Job

If you’re looking for a role writing Selenium scripts or clicking through UI flows, this isn’t it.

This role is about streams. Real-time audio and video streams — the kind that flow through calls and video conferences — replayed at high speed, high volume, and high fidelity against our systems to prove they work. We acquire real-world media data; your job is to orchestrate its replay with enough precision and control that our systems can’t tell the difference from live. You’ll design and build the simulation and testing infrastructure that drives how we evaluate our product, measure its performance, and prove correctness at scale.

The core artifact is a stream replay and orchestration engine. When something needs to be tested, the question isn’t whether you can automate it — it’s whether your engine can make the test indistinguishable from the real thing.

What You’ll Build

This is a greenfield infrastructure ownership role centered on one core challenge: a stream replay and orchestration engine.

Our product operates on real-time audio and video streams — the kind that flow through calls and video conferences. We acquire real-world media data; your engine needs to replay it convincingly and at scale: controlling timing, rate, and fidelity, injecting streams through our pipelines, and validating what comes out the other side. Done right, this single platform becomes the foundation for everything — eval testing, performance testing, end-to-end validation, and the environments we use to run live demos.

How you’d architect that is something we’re genuinely curious about. There’s no prescribed answer. We have opinions, but we’re looking for someone who has thought hard about this class of problem and can bring a point of view to the table.

What You’ll Do

• Design and implement stream replay systems that orchestrate real-world media data at volume — controlling playback rate, timing fidelity, and stream conditions to exercise our systems under realistic and adversarial scenarios

• Build integration emulators and harnesses that can stand in for third-party systems, control external interfaces, and exercise our product in isolation or in combination

• Automate environment provisioning for both testing and demo scenarios — environments should spin up consistently, tear down cleanly, and leave no surprises

• Define and own metrics that actually matter: throughput, latency distributions, error rates, accuracy under load — and build the dashboards and alerts that track them

• Work directly with engineering, product, and research to understand what “correct” looks like, and build the validation logic that proves it

• Champion a culture of testability — pushing for instrumentation, observability, and automation from the earliest stages of design

• Use the product daily; your firsthand experience with how it performs is part of the job

What We’re Looking For

• You think in data first. You understand data structures, distributions, and pipelines. You’ve built systems that ingest, transform, replay, or validate data at volume — and you know the difference between a test that approximates reality and one that actually replicates it.

• You’re a systems thinker. You understand how software behaves under load, at the edges, and when integrations misbehave. You design for failure modes, not just happy paths.

• You build frameworks, not one-off scripts. You write automation that other engineers can extend, understand, and trust. Your test infrastructure is production-quality code.

• You know how to control what you can’t control. You’ve emulated external systems, mocked integrations, and found ways to drive GUIs or interfaces programmatically when there was no other way in.

• You’re rigorous about correctness. You don’t just check that things run — you define what “correct” means and prove it, at scale, repeatedly.

• You can operate across the stack. From low-level data manipulation to system orchestration to pipeline validation — you’re comfortable wherever the problem takes you.

• You ship. Great frameworks that never land don’t help anyone. You balance quality with momentum and know how to iterate toward something excellent.

Technical Competencies

Strong candidates will have depth in several of the following and be willing to grow in the rest:

Languages & Runtimes

• Python — for data generation, scripting, test frameworks, and analysis pipelines

• Go or Rust — for high-performance simulation engines and data generation at speed

• C — for low-level system integration and performance-critical components

Data & Messaging

• SQL and relational databases — for validation queries, ground truth comparisons, and result analysis

• Messaging systems (Kafka, RabbitMQ, NATS, or similar) — for simulating and validating event-driven pipelines

Automation & Integration Control

• GUI automation on Linux, Windows, and macOS — programmatic control of desktop interfaces when API access isn’t available

• Integration emulation and mocking — building stubs and simulators that stand in for real third-party systems

Infrastructure & Tooling

• Scripted environment provisioning — repeatable, reliable setup and teardown

• Observability tooling — metrics, tracing, logging, and dashboards that surface what matters

Why GetReal Security

Our mission shapes what we build and how we build it. Here’s what that means for this role:

• You’ll own the test infrastructure from the ground up — no inherited mess, no politics around what you can change

• The problems are genuinely hard: high-speed data, complex integrations, and correctness requirements that matter at the highest stakes

• A small, senior team means you’ll work directly alongside the engineers, researchers, and product leaders building the systems you’re testing

• We use what we build every day — you’ll have real product context, not just ticket descriptions

• Your work will be visible: if testing is good, the team ships faster and with more confidence — and that confidence matters when the product is protecting people from fraud

This is a hybrid position in Austin, TX and remote.