send resumes to [email protected]

About the role

We design and build embedded multi-camera systems purpose-built imaging units that run perception on-device and are deployed in real environments, not on a lab bench. We are hiring a senior engineer to own the embedded software and on-device computer vision side of these units end to end.

This is a hands-on, ownership-heavy role. You will be the person who brings up a current sensor on a new carrier board, gets the computer vision stack running well on the compute it actually has, makes the pipeline hit its latency and power budget, deploys it to units in the field, and then keeps all of it healthy through dozens of software and hardware iterations. If you like the part of the job where hardware, systems software, computer vision and release engineering meet — and you have the patience for the debugging that lives there — this role is built for you.

What you will own

Embedded camera system development

- Bring up image sensors on new and revised carrier boards: MIPI CSI-2 / GMSL2 links, I2C/SPI control paths, clocking, power sequencing and reset ordering.
- Write and maintain V4L2 sensor drivers, device tree overlays and kernel-side plumbing; debug at the level of register dumps, oscilloscope traces and link error counters.
- Own multi-camera capture: hardware trigger and sync design, frame-level timestamping, and verification that streams are actually aligned rather than nominally aligned.
- Build and maintain the capture-to-application pipeline — ISP configuration, format conversion, encoding, buffer management and the interfaces the rest of the product consumes.
- Own calibration plumbing on-device: intrinsics and extrinsics storage, versioning, provisioning at manufacture and validation in the field.

Computer vision software on the camera boards

- Engineer and own the computer vision software that runs on our camera boards — from the capture interface through pre-processing, inference and post-processing to the output the product consumes.
- Take vision models and algorithms from a research or prototype state to a production on-device implementation: correct, deterministic, resource-bounded and maintainable.
- Own the on-device inference runtime — model conversion, quantization, accelerator backends and the fallback paths for when a backend is unavailable.
- Define and defend accuracy on the target hardware: build the evaluation harness, hold a reference dataset, and detect regressions in output quality as rigorously as regressions in latency.
- Manage the vision software as a product surface — versioning, configuration, backwards compatibility of outputs, and clear contracts with the teams and systems downstream of you.
- Work with the computer vision and robotics teams to translate algorithmic requirements into what the board can actually deliver, and push back with measurements when the two do not meet.

Performance and optimization

- Profile and drive down end-to-end latency, jitter and CPU load across the full path from sensor readout to consumed output.
- Eliminate avoidable copies: DMA-BUF and zero-copy buffer sharing, memory bandwidth budgeting,



cache and allocator behaviour on constrained SoCs.
- Move work onto the right silicon — GPU, NPU, ISP or dedicated video blocks — and measure the result rather than assuming it.
- Optimize and quantize on-device inference for the target accelerator, and hold the line on the accuracy-versus-throughput trade-off with data.
- Work inside thermal and power envelopes: sustained-load testing, throttling behaviour, and designing so that performance does not quietly degrade after ten minutes of operation.

Edge deployment

- Own the deployable image for our edge compute platforms — embedded Linux BSP, kernel configuration, root filesystem, and the build system that reproduces it (Yocto, Buildroot or vendor equivalent).
- Containerize and package the vision runtime so that what runs on a developer desk is the same thing that runs on a unit in the field.
- Design and operate over-the-air update: signed images, A/B or fallback partitions, safe rollback, and update paths that survive a power cut mid-flash.
- Build device provisioning, first-boot configuration, identity and fleet inventory so units can be deployed by a field team rather than by an engineer.
- Instrument units for remote health and diagnostics — logs, metrics, crash artefacts and enough context to debug a failure you cannot physically reach.

Board and platform maintenance across iterations

- Act as the software owner of the board across its lifetime: carry support forward through hardware revisions, component substitutions and sensor changes without forking the codebase into unmaintainable variants.
- Maintain a clear compatibility matrix of hardware revision, BSP version, firmware, vision model and application release — and make it enforceable, not aspirational.
- Handle kernel and vendor BSP upgrades, including carrying, rebasing and eventually retiring out-of-tree patches.
- Triage field failures with the capture and hardware teams, drive root cause to a real fix, and convert each one into a regression test.
- Keep bring-up, flashing and board-specific procedures documented well enough that someone else can execute them.

CI/CD and release engineering for camera products

- Build and own the CI/CD pipeline for embedded camera and vision software: automated cross-compilation, image builds, artefact and model versioning, and signed, traceable releases.
- Stand up and maintain hardware-in-the-loop test infrastructure — real boards with real sensors on a rack, running automated smoke, stream-integrity, sync, accuracy and performance tests on every change.
- Define the automated gates a release must pass: frame drops, latency percentiles, sync error, vision output accuracy, thermal soak, boot reliability, update and rollback success.




- Automate flashing and provisioning so that producing and deploying a release is a repeatable operation rather than a tribal ritual.
- Own release hygiene: branching and versioning strategy, release notes, reproducible builds, and the ability to say exactly what software and which model version is on any given unit.

What we are looking for

Required

- 5–10 years building embedded systems software in a product context, with meaningful time spent on camera or imaging systems specifically.
- Strong C and C++; strong Python for vision work, tooling, test and automation.
- Deep, practical embedded Linux experience: kernel and driver work, device tree, V4L2, build systems, and the debugging that comes with all of it.
- Demonstrated camera bring-up experience — you have taken a sensor from “nothing on the bus” to a stable, characterized stream.
- Proven experience deploying and owning computer vision software on embedded hardware, including model optimization for on-device inference.
- Solid working knowledge of computer vision fundamentals — camera geometry, calibration, multi-view reconstruction, and the practical failure modes of vision models in the field.
- Hands-on experience deploying to embedded SoC compute platforms (NVIDIA Jetson family, Qualcomm, TI, NXP or similar) in production.
- Real optimization experience on constrained hardware, backed by profiling rather than intuition.
- Working ownership of CI/CD for embedded software, including automated testing against actual hardware.
- Comfort with hardware lab work: schematics and datasheets, logic analyzer, oscilloscope, bench power supply, and collaborating closely with electrical and mechanical engineers.
- Engineering judgement to work with incomplete information, and the discipline to verify before declaring something fixed.

Strongly preferred

- Multi-camera synchronization, stereo or rig-based systems; understanding of rolling versus global shutter and the practical consequences of each.
- CUDA, TensorRT, OpenCL, ONNX Runtime or vendor NPU toolchains for on-device acceleration.
- OpenCV and modern deep-learning frameworks in a deployment context, not only in training.
- Camera calibration in practice — intrinsics, extrinsics, distortion models, and how they degrade in the field.
- GStreamer or comparable media frameworks; video encoding and streaming at scale.
- Yocto layer authorship and maintenance.
- OTA frameworks, secure boot and device identity.
- GMSL / FPD-Link serializer-deserializer systems, or high-speed interface design exposure.
- Experience supporting hardware through EVT/DVT/PVT and into volume production.
- Familiarity with robotics or spatial perception workloads as the consumer of your pipeline.

Why this role

- Genuine ownership of a full platform — hardware interface, systems software and the vision stack on top — not a narrow slice of someone else’s stack.
- Hardware and software under one roof — short feedback loops with the people designing the boards and running the deployments.
- Work that ships into real environments and is measured against real-world outcomes.
- Technical depth is respected here; this is a senior individual-contributor track with room to grow into platform leadership.

📌 Senior Embedded Camera Systems Engineer (Hyderabad)
🏢 DreamVu
📍 Hyderabad