Who we are:
We are a start-up based out of Bengaluru & Delhi NCR. We are engaged in development of next generation missions and technologies (NGM&T) towards future warfare needs of the Indian defence forces. It is undertaking research towards enhancing persistence and autonomy for unmanned vehicles and robotic swarms. NRT’s product development portfolio includes a solar power stratospheric high altitude pseudo satellite (HAPS) unmanned platform and an air/ground launched stand-off autonomous system.
Role Summary:
We’re hiring a Software Engineer to help build and ship production-grade perception systems for real robots operating in real environments. This role is hands-on, execution-focused, and tightly integrated with autonomy, hardware, and field operations (distributed systems, networking, and deployment tooling a plus). ROS/ROS2 and prior robotics application experience are required.
What You’ll Do:
-
Build and ship perception pipelines deployed on physical robotic systems.
-
Develop ROS/ROS2 nodes and distributed systems for real-time perception (publish/subscribe, services, actions, TF).
-
Build reliable inter-process and inter-device communication for on-robot and offboard perception (DDS/ROS2 networking, bandwidth/latency considerations).
-
Integrate and validate multi-sensor data (e.g., camera, LiDAR, radar, IMU, GPS) into reliable outputs for autonomy.
-
Implement and improve perception components (sensor drivers/interfaces, calibration plumbing, synchronization, preprocessing, detections/tracks integration, quality checks).
-
Debug and harden systems where sensor data is noisy, incomplete, and imperfect.
-
Collaborate with autonomy, hardware, and field teams to deploy quickly and iterate based on real-world results.
-
Set up, configure, and debug SITL (Software-in-the-Loop) environments to validate perception outputs and message flows before on-robot testing.
-
Improve runtime performance (latency/throughput), reliability, logging/telemetry, and maintainability.
-
Package and deploy services using Docker on-robot systems.
Must-Have Qualifications:
-
2–3 years experience building real-world software, with exposure to robotics/perception systems.
-
ROS/ROS2 is required (experience building and debugging ROS-based systems through projects, internships, or professional roles).
-
Experience with SITL setup and debugging workflows (simulation, message flow validation, bag/replay, test scenarios).
-
Prior robotics application experience is required (robots, autonomous vehicles, drones, industrial automation, etc.) — this can include strong academic projects or internships, not only full-time roles.
-
Strong programming skills in Python or C++.
-
Working knowledge of Linux networking fundamentals (TCP/UDP, debugging connectivity issues, bandwidth/latency tradeoffs).
-
Experience taking perception-related work from development to on-robot testing (field trials, lab testing, or production-like environments).
-
Working understanding of sensor timing/synchronization, and comfortable doing system-level debugging in distributed robotics systems (network issues, time sync, message drops).
-
Comfortable making pragmatic engineering tradeoffs to meet performance and deployment goals.
-
Working knowledge of Docker for packaging and deploying robotics services.
-
Able to work on-site.
Strongly Preferred:
-
Exposure to sensor fusion, mapping, object detection/tracking, or multi-object tracking.
-
Familiarity with common robotics/perception tooling (e.g., tf2, rosbag, rviz, image_transport, calibration pipelines).
-
Familiarity with networking and communication for distributed robotics systems (multi-machine ROS/ROS2, DDS config, TCP/UDP basics, time sync).
-
Familiarity with SITL setup, configuration, and debugging to speed iteration before field testing.
-
Experience deploying to edge computers (e.g., NVIDIA Jetson) and optimizing runtime performance.
-
Field deployment experience: diagnosing issues from logs, telemetry, and on-robot behavior in messy environments.
-
Startup / rapid iteration background.
What Success Looks Like:
-
Perception outputs that are reliable enough to support autonomy in real conditions (not just offline metrics).
-
ROS/ROS2 perception stack that’s observable and debuggable (good logging, replay, tooling discipline).
-
Faster iteration loop from field feedback to shipped improvements.
Interview Focus Areas:
-
Python engineering fundamentals for robotics software
-
ROS/ROS2 architecture and debugging (TF, timing, message flow, bags, multi-machine networking/communications, SITL workflows)
-
Deployment fundamentals: Docker-based packaging and runtime debugging on Linux.
-
Perception fundamentals + pragmatic production decisions
-
Real-world deployment stories: failures, fixes, and what you learned
