We build software that gives robotics engineers clarity in complex robotic systems. Our tool makes
(ROS‑based) robotic systems observable, understandable, and actionable — so developers can build
safer, more capable robots with confidence.
We are SMAROBIX — a team of 5 founders with complementary skill sets and different cultural
backgrounds and a TU Dresden start-up. This role is part of the core team shaping the product’s
foundations. Type: Full-time (Dresden-based preferred; hybrid welcome for EU-based candidates)

THE ROLE
You’ll work on understanding robotic systems as they run under real conditions. ROS‑based systems
are dynamic and opaque at runtime: components appear and disappear, communication crosses
process boundaries, and timing and reliability guarantees must hold under load. Capturing what
actually happens, at the right level of detail and with minimal overhead, is a hard systems problem
without an established solution in this domain. This is a hands‑on, design‑and‑build role. The
challenge is not adding instrumentation in the abstract, but deciding what is important, how to
understand it, and how to represent it so the rest of the product has reliable ground truth to reason
from. The software runs directly on production robots, where correctness and low overhead are not
negotiable. There is no template to follow; progress depends on understanding the constraints deeply
and designing within them rather than hoping they don’t matter.

WHAT WE’RE LOOKING FOR
You’re comfortable working close to the metal, where operating system behavior, memory,
concurrency, and timing are explicit design concerns rather than hidden details. Reasoning clearly
about what happens inside a running system is where you excel due to having actually programmed
and debugged at the lowest level. You understand robotic middleware not as a black box but as part
of the system that need to be understood in detail. You’re familiar with how nodes communicate, how
data moves across process boundaries, and what quality‑of‑service settings mean in practice
beneath the surface. You’ve worked with observability or instrumentation in environments where
overhead is a real cost, and you reason carefully about the trade‑offs between visibility, precision,
and impact. You’re able to zoom out from low‑level implementation details and make architectural
decisions that hold up over time. You approach tools pragmatically, choosing methods that fit the
constraints rather than forcing familiar patterns onto novel problems. In a small team, you
communicate clearly, take responsibility for reliability in user environments, and are willing to work
beyond strict role boundaries when it improves the product. Prior work with kernel modules,
deterministic networking, real-time operating systems, or observability tooling as well as experience
with embedded targets or hardware acceleration gives you a head start, however, what we care about
is genuine depth and the drive to ship. Same holds true for whether you come from academia,
industry, or an unexpected path.

WHY THIS ROLE
You won’t be maintaining an existing runtime tracing system or implementing a predefined spec. It is
up to you to build a system up and find the right solutions under unusual constraints. The foundation
exists, but the critical decisions about what constitutes trustworthy enough is still open. What you
capture, and how you capture it, becomes the ground truth everything else in the product depends
on. You’ll work closely with the co‑founder responsible for runtime architecture, with real ownership
and room to challenge assumptions. This is a role for engineers who want their system‑level
judgment to shape a product from the inside. As the team grows, this work naturally develops into
technical leadership through clarity and influence rather than formal hierarchy.

HOW TO APPLY
Send your CV and a short cover letter via E-Mail. In your cover letter, tell us about a hard
technical problem you worked on and the moment you realized your first approach was wrong —
what did you do?