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

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.

How to Apply Send your application to jobs@iris.de with:

1. Your CV.
2. A brief, concrete description (½–1 page) of a production system you built or owned — what the latency or throughput target was, what the hardest technical problem was, and how you solved it.

Applications without a concrete production system description will not be reviewed.

Applications submitted via LinkedIn will not be reviewed — please apply by email only.