Systems Engineer — Real-Time Processing (Rust / C++)
Department: Core Systems Engineering | Employment Type: Full-time | Location: Hybrid (3 days on-site · 2 days remote) · Urbar near Koblenz, Germany

The Role
Our real-time fraud prevention engine processes more than 100 billion payment transactions per year under strict latency and zero-downtime requirements. We are strengthening our core systems team with a senior engineer who has shipped and operated production software across the full range of systems work — from the unglamorous to the highly technical — and who takes the same care with both.

This is a production engineering role, not a research position. The work is varied: some of it is genuinely demanding (lock-free concurrency, cache-line discipline, profiling p99.9 jitter on bare metal), and a meaningful portion of it is not — configuration parsing, serialization correctness, tooling improvements, test harness maintenance, fixing edge-case bugs in subsystems you did not write. We need an engineer who executes both kinds of work with the same professional standard, because a production system is only as reliable as its least-glamorous component.

You will work alongside a small, senior team and collaborate directly with engineering leadership on architecture decisions that have immediate, measurable impact on live systems.

Identify and eliminate hot-path bottlenecks: profile p99.9 tail latency on Linux using perf and flame graphs, and translate findings into concrete code changes.
Design and implement lock-free concurrency models (SPSC/MPMC ring buffers, atomic memory ordering, cache-line alignment).
Design low-overhead IPC using POSIX shared memory and memory-mapped ring buffers between co-located processes.
Define zero-allocation hot-loop policies: arena allocators, static pre-allocated pools, alignas(64) discipline.
Write, review, and maintain production Rust/C++ code across the full codebase — configuration handling, serialization formats, protocol parsing, internal tooling.
Build and maintain sanitizer pipelines (ASan, TSan), regression suites, and CI/CD benchmarking harnesses.
Diagnose and fix correctness bugs, edge-case failures, and integration issues under real production load.
Instrument systems with structured observability (metrics, traces, latency histograms) and act on what the data shows.
Contribute to architecture decisions with evidence-based input, written documentation, and clear trade-off reasoning.

5+ years of professional experience writing and shipping production software in Rust and/or modern C++ (17/20/23) — in a team, under real operational constraints.
A track record of maintaining and improving existing production codebases you did not author, not just building greenfield systems from scratch.
Demonstrated experience in at least one latency-sensitive or high-throughput production domain: fintech, payments, high-frequency trading, exchange infrastructure, telecommunications core, or equivalent — where performance constraints were real operational requirements, not benchmarks.
Practical knowledge of lock-free concurrency sufficient to implement and debug it in production: atomics, memory ordering, SPSC/MPMC rings, false-sharing elimination.
Working proficiency with Linux performance profiling — you have used perf, flame graphs, or hardware performance counters to find real bottlenecks in production, not just in toy benchmarks.
Solid grasp of Linux systems programming: mmap, POSIX IPC, file I/O semantics, threading primitives.
Comfort running AddressSanitizer (ASan) and ThreadSanitizer (TSan) as standard CI/CD practice.
Fluent spoken and written English.

Strong Differentiators

Background in high-frequency trading, exchange infrastructure, real-time payments, or 5G/telecom core packet processing — domains where missing a latency SLA has real, immediate consequences.
Experience designing and implementing service interfaces — gRPC/Protobuf, REST APIs, shared memory IPC, or other inter-process communication contracts — with particular attention to versioning, backward compatibility, and operational observability.
Experience with POSIX shared memory IPC and lock-free ring buffers as an IPC transport between co-located processes.
Hands-on experience with Rust unsafe, FFI boundaries, and cross-language interoperability with C/C++ libraries.
Experience tuning Linux kernel parameters for low-latency workloads: CPU core isolation (isolcpus), NUMA awareness, huge pages, real-time scheduling policies.
Contributions to open-source systems projects, published benchmarks, or documented production post-mortems that demonstrate engineering depth.

A senior engineering position with direct ownership over performance-critical production systems.
A small, senior team — no ticket queues, no over-process; architectural decisions made by the engineers closest to the code.
Direct collaboration with engineering leadership in a flat, engineering-driven culture.
Hybrid working model: 3 days on-site in Urbar near Koblenz, 2 days remote.
A modern workplace with access to the latest hardware in a relaxed setting (former monastery near Koblenz).
Continuous professional development and team investment.

FSJB1_DE

IRIS Analytics GmbH