Systems Engineer — Real-Time Processing (Rust / C++)

IRIS Analytics; Urbar; Hybrid; EUR 90,000 - 120,000; Full time

Benefits offered by this job

Hybrid work model

Modern workplace near Koblenz

Job summary

IRIS Analytics seeks a Systems Engineer — Real-Time Processing to join our Core Systems Engineering team in a hybrid setup at Urbar near Koblenz, Germany. The role emphasizes production-grade Rust/C++ development for a high-throughput real-time engine with stringent latency constraints.

You will work on profiling hot paths, designing lock-free data structures, and implementing efficient IPC and memory management. Fluency in English and a track record in latency-sensitive domains are essential.

Qualifications

• 5+ years of production Rust and/or C++ experience in a team.
• Experience maintaining production codebases you did not author.
• Fluent English communication and collaboration.

Responsibilities

• Identify and eliminate hot-path bottlenecks with profiling.
• Design and implement lock-free concurrency models (SPSC/MPMC).
• Implement low-overhead IPC using POSIX shared memory and ring buffers.
• Define zero-allocation hot-loop policies and arena allocators.
• Maintain production Rust/C++ code across the codebase and tooling.

Skills

Rust

C++

Performance optimization

Linux

Systems programming

English

Tools

perf

flame graphs

mmap

POSIX IPC

ASan

TSan

Job description

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.

What You Will Work On

• 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.

What We Require

• 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.

We Offer

• 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.