Middleware Developer (C&C++) — ADAS (Bengaluru)

Middleware Developer (C&C++) — ADAS (Bengaluru)

16 Nov
|
Vayavya Labs
|
Bengaluru

16 Nov

Vayavya Labs

Bengaluru

Position Name: Middleware Developer (C&C;++) — ADAS

Years of Experience: 3- 7 years

Location: Bengaluru, Karnataka

About Vayavya Labs

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. We are expanding our middleware and platform-software capability to support the next generation of software-defined vehicles, where robust, well-architected middleware is what connects hardware to the applications that run on it.

About the Role

We are looking for a C/C++ Middleware Developer to design, implement, and maintain the middleware layer of a vehicle compute platform built for ADAS and autonomous driving. This is the layer where inter-process communication frameworks, service daemons, hardware abstraction interfaces, and system services come together to carry sensor data and control signals between low-level drivers and the autonomy software that depends on them. You will work within and contribute to the team’s in-house C++ middleware frameworks — not building from scratch in isolation, but extending, hardening, and optimizing a shared codebase that other engineers build on. The role combines strong C++ systems programming with an understanding of how embedded software stacks are organized — from device drivers through middleware services to application interfaces. You will collaborate closely with firmware engineers, driver developers, perception and planning teams, and will be expected to write production-quality, testable, well-documented code that runs in resource-constrained, safety-adjacent environments. You should be comfortable working in a large, shared C++ codebase with established patterns, contributing clean code that other engineers review, extend, and rely on.

What You’ll Do

- Design and implement middleware components in C++ (C++14/17) that provide well-defined interfaces between platform services, device drivers, and application software.
- Develop and maintain inter-process communication (IPC) frameworks — D-Bus like services, shared-memory interfaces, zero-copy transports (e.g. Eclipse iceoryx), POSIX message queues, and Unix domain sockets — for reliable, low-latency communication between system daemons, sensor pipelines, and application software.
- Implement system services and background daemons on embedded Linux — managing lifecycle, configuration, logging, health monitoring, and error recovery.
- Write and integrate hardware abstraction layers (HALs) that expose sensor data, actuator controls, and peripheral status to higher-level software through clean, versioned APIs.
- Develop middleware for vehicle communication stacks — receiving and routing CAN, Ethernet, or serial data from the platform’s networking layer and exposing it to application consumers as structured service interfaces.
- Build and maintain configuration management, parameter storage, and runtime-tunable settings frameworks for embedded platforms.
- Work within and contribute to the team’s in-house C++ middleware frameworks — understanding the existing architecture,



following established coding patterns and API conventions, and extending the framework with new modules as the platform evolves.
- Integrate third-party and silicon-vendor SDKs into the middleware stack — wrapping vendor libraries behind clean, testable C++ interfaces that isolate the rest of the platform from vendor-specific APIs and versioning.
- Develop middleware components for sensor data routing — receiving high-bandwidth data from camera, lidar, and radar interfaces and delivering it to perception and fusion consumers through well-defined, latency-aware service interfaces.
- Implement platform health monitoring and diagnostics services — collecting hardware status, software health metrics, and error conditions from across the middleware stack and exposing them for logging, alerting, and fleet-level telemetry.
- Profile and optimize middleware for CPU usage, memory footprint, latency, and thread safety using tools such as perf, Valgrind, strace, and GDB.
- Write unit tests (Google Test / Google Mock), integration tests, and system-level tests for middleware components, and integrate them into CI/CD pipelines.
- Collaborate with firmware engineers on bring-up and integration — understanding how middleware depends on driver and BSP behavior, and debugging issues that span the middleware-driver boundary.
- Participate in architecture and design reviews, contribute to coding standards, and maintain clear technical documentation for middleware APIs and service interfaces.

What You’ll Bring

- 3–7 years of hands-on C/C++ software development experience, with at least 2 years focused on middleware, platform services, or system-level software.
- Strong modern C++ skills (C++14 or later) — comfortable with RAII, smart pointers, move semantics, STL containers and algorithms, templates, and lambda expressions in production code.
- Solid understanding of Linux system programming — processes, threads (pthreads / std::thread), synchronization primitives (mutexes, condition variables, semaphores), signals, file descriptors, epoll/select, and the POSIX API.
- Experience designing and implementing IPC mechanisms — at least one of: D-Bus (sd-bus or GDBus), shared memory, POSIX message queues, Unix domain sockets, or named pipes — in a multi-process embedded or systems-software context.
- Working knowledge of the Linux build and packaging ecosystem — CMake (and ideally colcon for ROS 2 workspaces) for build, pkg-config for dependency management, and familiarity with cross-compilation toolchains for ARM targets.
- Comfortable with debugging and profiling tools — GDB, Valgrind (memcheck, helgrind), strace, ltrace, and perf — for diagnosing memory leaks, race conditions, deadlocks, and performance bottlenecks.
- A structured approach to software quality — unit testing with Google Test / Google Mock, static analysis (cppcheck, clang-tidy), and code review discipline.




- Valuable understanding of version control workflows with Git, and experience with CI/CD pipelines (Jenkins, GitLab CI, or similar).
- Comfort working in a large, shared C++ codebase — reading and understanding existing code, following established patterns and API conventions, writing code that fits the team’s style and passes review.
- Awareness of Linux real-time concepts — PREEMPT_RT, CPU affinity, scheduling policies, and cgroups — at least enough to reason about latency-sensitive middleware behavior and work with engineers who tune these.

Nice to Have

- Experience with embedded Linux distribution building — Yocto / OpenEmbedded, Buildroot, or custom rootfs generation — including writing recipes, configuring layers, and integrating middleware packages into a BSP.
- Exposure to Linux device driver development — character drivers, platform drivers, or interfacing with kernel subsystems (sysfs, procfs, ioctl, DMA) — even at the level of reading and debugging existing drivers.
- Experience with embedded firmware development on microcontrollers (ARM Cortex-M, RISC-V) and an RTOS (FreeRTOS, Zephyr, or QNX) — helpful for understanding the firmware layer that middleware sits on top of.
- Familiarity with D-Bus system architecture — writing D-Bus services and clients, understanding the session bus vs. system bus, introspection, signal emission, and method calls using sd-bus (systemd) or GDBus (GLib).
- Exposure to automotive middleware and communication protocols — CAN, SOME/IP, AUTOSAR Adaptive, UDS — at any level (application, middleware, or driver).
- Experience with serialization frameworks — Protocol Buffers, FlatBuffers, or Cap’n Proto — for structured, versioned data exchange between middleware services.
- Familiarity with systemd service management — writing unit files, managing dependencies, socket activation, watchdog integration, and journal-based logging.
- Exposure to functional safety concepts (ISO 26262) or safety-critical software development practices (MISRA-C/C++, static analysis, ASPICE).
- Exposure to ROS 2 and DDS-based middleware — node architecture, executors, QoS policies, launch files, and lifecycle management — even at a user level rather than contributor level.
- Familiarity with zero-copy IPC frameworks such as Eclipse iceoryx, or shared-memory DDS transports, for high-bandwidth sensor data paths.
- Working knowledge of ADAS or autonomous driving concepts — perception, sensor fusion, localization, planning — at least enough to understand what the middleware serves and why latency and reliability matter.
- Experience integrating third-party or silicon-vendor SDKs into a larger platform — wrapping vendor APIs, managing ABI/API compatibility, and isolating vendor dependencies.

Why Join Us

You’ll work on the middleware that carries sensor data and control signals through an ADAS vehicle compute platform — the layer between the hardware and the autonomy software that depends on it. It’s an environment for engineers who care about clean interfaces, low-latency data paths, and code that runs reliably on real hardware in the field. You’ll contribute to a shared C++ codebase alongside firmware, driver, and perception engineers, solving problems that span the full stack.

Apply Here

📌 Middleware Developer (C&C++) — ADAS (Bengaluru)
🏢 Vayavya Labs
📍 Bengaluru

Reply to this offer

Impress this employer describing Your skills and abilities, fill out the form below and leave Your personal touch in the presentation letter.

Subscribe to this job alert:

Get the latest job offers by email for: middleware developer (c&c++) — adas (bengaluru) / bengaluru

Subscribe to this job alert:

Get the latest job offers by email for: middleware developer (c&c++) — adas (bengaluru) / bengaluru