Staff / Principal Engineer – Middleware

Vayavya Labs; Bengaluru; On-site; INR 3,500,000 - 5,500,000; Full time

Job summary

Vayavya Labs Pvt. Ltd. is seeking a Staff/Principal Engineer to architect and lead the Linux middleware layer of a large vehicle compute system. Modern C++ and ROS 2 will shape the platform, with emphasis on low-latency data paths and real‑time performance for safety‑critical systems.

You will own the technical roadmap, set engineering standards, and provide oversight across software, hardware, and systems teams, while mentoring senior engineers to raise the bar on design quality and reliability.

Qualifications

• Proficient in modern C++ (C++14/17/20) and Linux systems.
• Hands-on experience with ROS 2, DDS, and middleware in automotive/embedded contexts.
• Strong background in kernel/user-space internals, scheduling, and performance profiling.
• Experience leading architecture of large, cross-functional platforms across software and hardware.

Responsibilities

• Architect and lead Linux-based vehicle compute platform design.
• Own ROS 2 architecture, executors, QoS, and DDS layer standards.
• Set C++ engineering standards, API conventions, testing in CI (gtest/gmock).
• Define SDK integration strategy with silicon vendors and internal libraries.
• Design low-latency data paths and real-time Linux decisions (PREEMPT_RT).
• Lead cross-functional collaboration and architecture reviews across teams.
• Mentor engineers and drive platform reliability and performance goals.

Skills

Modern C++

ROS 2

DDS

Linux kernel

Networking

Systems engineering

Leadership

Autonomous driving

Tools

GoogleTest

GoogleMock

colcon

CMake

Job description

Position: Staff / Principal Engineer- Middleware

Years of Experience: 8+ Years

Vayavya Labs builds embedded software and firmware for the semiconductor and automotive industries, with deep expertise in low-level device software, driver automation, and safety-critical systems. Our engineers work close to the metal — bringing up silicon, writing production firmware, and validating it to the standards demanded by modern and autonomous vehicles — and increasingly at the compute, middleware, and networking layers that connect autonomy software to the vehicle’s hardware platforms. This is a role for a technical leader who wants to shape that platform end to end.

About the Role

We are looking for a Staff / Principal Engineer to architect and lead the Linux platform and middleware layer of a large, complex vehicle compute system — the layer where ROS 2, communication middleware, networking, and the operating system come together to carry autonomy and ADAS software reliably onto real hardware. Modern C++ is the primary language for this role, and you will set the bar for how C++ is designed, tested, and integrated across the platform.

You will think at the level of the whole system: how compute nodes, sensors, networks, and software components interact, where latency and failures come from, and how the platform should evolve as it scales across programs and fleets. You will own the technical roadmap for the platform, set the engineering standards that keep it fast and dependable, and provide deep technical oversight across software, hardware, and systems teams.

This is a hands-on leadership position. You will still be in the code and on the target for the hardest problems — from Linux kernel and scheduler tuning to ROS 2 executor behavior and multi-layer networking — while mentoring senior engineers and driving architectural decisions that scale.

What You’ll Do

• Architect and lead the design of the Linux-based vehicle compute platform, ensuring a modular, scalable interface between autonomy/ADAS software and the underlying hardware.
• Own the ROS 2 architecture — node and process layout, executors and callback groups, QoS policies, launch and lifecycle management, and the DDS layer underneath — and set standards for how application teams build on it.
• Set the C++ engineering standards for the platform — modern C++ (C++17/20) design, API conventions, code reviews, static analysis, and unit testing with GoogleTest (gtest) and GoogleMock (gmock) as a required part of CI.
• Define the SDK architecture and integration strategy — how silicon-vendor SDKs, BSPs, middleware, and internal libraries are wrapped, versioned, and integrated behind clean, testable C++ APIs that application teams build on.
• Design and optimize the middleware data path for low-latency, high-bandwidth sensor and control data, including DDS vendor selection and tuning, shared-memory / zero-copy transport, and serialization choices.
• Drive Linux platform decisions for real-time and determinism: kernel configuration, PREEMPT_RT, scheduling policies, CPU isolation and affinity, cgroups, memory management, and interrupt handling.
• Lead systems engineering for the compute and networking platform — requirements, interface definitions, end-to-end latency and bandwidth budgets, failure-mode analysis, and traceability from system requirements down to software components.
• Architect vehicle and in-platform networking across OSI Layers 1–4 and above — Ethernet, CAN, UDP/TCP, and time synchronization — and how middleware traffic maps onto it.
• Lead cross-functional integration of new sensors and compute devices into the middleware stack, and define standards for data interfaces between teams.
• Drive the technical roadmap for platform health monitoring, diagnostics, and fleet-wide performance optimization.
• Establish engineering standards for Hardware-in-the-Loop (HIL) and Software-in-the-Loop (SIL) testing, simulation-based validation, and automated performance profiling.
• Provide technical oversight on complex, cross-layer issues that span application code, ROS 2 and DDS, the Linux kernel, drivers, and the network.
• Mentor senior engineers and raise the technical bar for design, code quality, and system reliability across teams.

What You’ll Bring

• 8+ years of software engineering experience, including leading architecture of large, complex systems at the hardware/software interface.
• Automotive industry background — experience delivering software for vehicle platforms, ECUs, or in-vehicle compute.
• Expert-level modern C++ (C++14/17/20) as your primary language — high-performance, thread-safe, memory-efficient Linux systems, with strong command of templates, RAII, concurrency, and the standard library.
• Proficiency with unit test frameworks, especially GoogleTest (gtest) and GoogleMock (gmock) — designing testable C++ code, mocking OS, middleware, and hardware dependencies, and running tests in CI.
• Experience with SDK architecture and integration — designing SDK APIs, integrating third‑party and silicon‑vendor SDKs into a platform, and managing versioning and ABI/API compatibility.
• Working knowledge of Python for tooling and automation; familiarity with CMake and colcon‑based builds.
• Deep Linux systems experience — kernel and user‑space internals, scheduling, memory, IPC, performance profiling (perf, ftrace, eBPF or similar), and platform bring‑up.
• Hands‑on production experience with ROS 2 and DDS‑based middleware, including QoS, discovery, and performance tuning.
• Strong networking background across the stack — low‑level (Ethernet, CAN, UDP, TCP) and high‑level (gRPC, RTP, HTTP) — and the ability to debug it with packet‑level tools.
• Systems engineering discipline: breaking down system requirements, defining interfaces, building latency and resource budgets, and reasoning about failure modes across a large system.
• The ability to understand complex systems end to end and explain them clearly to software, hardware, and program teams.
• Demonstrated cross‑functional leadership across software, hardware, and systems teams, with a track record of shipping complex platforms.

Nice to Have

• Real working knowledge of autonomous driving and ADAS systems — perception, sensor fusion, localization, planning, and control — and what they need from the platform.
• Experience with autonomy sensors — lidar, radar, and camera — and their integration into low‑latency data pipelines.
• Time‑Sensitive Networking (PTP / gPTP) and Ethernet switching.
• Automotive middleware and frameworks such as SOME/IP, AUTOSAR Adaptive, or zero‑copy IPC frameworks (e.g. Eclipse iceoryx).
• Functional safety and process standards such as ISO 26262 and ASPICE.
• Heterogeneous compute performance optimization across CPU, GPU, and accelerators.
• Containerization and orchestration on embedded Linux, and experience building distributed fleet health‑monitoring frameworks.

Why Join Us

You’ll set the technical direction for the Linux and middleware backbone of autonomous‑vehicle platforms — work that spans silicon to fleet, and code to architecture. It’s a role for an engineer who wants both the ownership of a principal‑level mandate and the satisfaction of solving the deepest system‑level problems on real hardware.