Octobotics Tech

Senior Robotics Engineer (ROS 2 Migration & Systems) - WorkFlow

Department: R&D Engineering

Location: Octobotics HQ (Noida/On-Site)

The Mission

To successfully migrate our legacy ROS 1 architecture to a high-performance ROS 2 Native ecosystem, architecting a navigation stack that survives the "unheard-of" edge cases of the real world.

1. The Context: The Great Migration

Octobotics is at a pivot point. Our legacy stack was built on ROS 1 (Noetic). It got us to MVP.

But to scale, we are tearing it down and rebuilding in ROS 2 (Humble/Iron).

We are not looking for someone to maintain old code. We are looking for an Architect to lead this migration. You will deal with the pain of bridging ros1_bridge, porting custom messages, and rewriting node lifecycles from scratch.

If you are afraid of breaking changes and complex dependency hell, stop reading now.

2. The "Scorecard" (Outcomes)

• The Migration: Port our core navigation and control logic from ROS 1 to ROS 2. This involves rewriting nodes to utilize Lifecycle Management and Node Composition for zero-copy transfer.
• Nav2 Architecture: We don't just "install" Nav2. You will write custom Behavior Tree plugins and Costmap layers to handle dynamic obstacles in unstructured environments.
• Middleware Optimization: You will own the DDS layer (FastDDS/CycloneDDS). You must tune QoS profiles for lossy WiFi environments and debug discovery traffic issues that traditional network engineers don't understand.
• Sensor Fusion & State Estimation: Implement and tune EKF/UKF pipelines (robot_localization) to fuse IMU, Wheel Odometry, and LiDAR. You must understand Covariance Matrices—if your covariance grows unbounded, you have failed.
• Serialization Strategy: Implement Protocol Buffers (Protobuf) for high-efficiency, non-ROS internal data logging and inter-process communication where overhead must be zero.

3. Technical Requirements (The Hard Skills)

The Stack (ROS 1 & ROS 2):

• Deep ROS 2 Mastery: You know the difference between spin(), spin_some(), and Multi-Threaded Executors. You understand why we are moving to ROS 2 (Real-time constraints, DDS security, QoS).
• Navigation Stack: In-depth knowledge of Nav2 (Planners, Controllers, Recoveries). You understand Global vs. Local planners (A*, DWB, TEB).
• SLAM & Localization: Experience with Graph-based SLAM (Cartographer, SLAM Toolbox). You know how to close loops and optimize pose graphs.

The Math (The "Weeder"):

• Linear Algebra & Geometry: Rigid body transformations are your second language. You understand Quaternions, homogeneous transformation matrices ($T \in SE(3)$), and how to avoid Gimbal Lock.
• Kinematics: You can derive Forward and Inverse Kinematics for Differential Drive and Ackermann steering chassis.
• Probabilistic Robotics: Understanding of Bayesian estimation. You know that sensors are noisy and that "Ground Truth" is a myth.

The Code:

• C++ (14/17): Real-time safe coding standards. RAII, Smart Pointers, and template metaprogramming.
• Python: For prototyping and complex orchestration.

4. The "Topgrading" Filter (Do NOT apply if...)

• You think roslaunch is the same as ros2 launch.
• You have never defined a custom .msg or .srv file.
• You struggle to visualize a TF tree in your head (map -> odom -> base_link).
• You think latency "doesn't matter" in a control loop.

5. The Challenge: Surfing the Tsunami

Let’s be honest: AMR (Autonomous Mobile Robots) is hard.

We are solving problems that are unheard of in the standard "warehouse" world. We deal with dynamic crowds, changing lighting, and network black holes.

There will be days when the Sensor Fusion drifts for no reason. There will be days when the DDS discovery fails because of a multicast storm. There will be architectural "Tsunamis" that threaten to wipe out our sprint.

We are looking for the engineer who doesn't run for higher ground, but grabs a board and says, "I’m ready to surf."

Senior C++/Qt Backend Engineer

(High-Performance Systems)

Location: Noida (On-site)

Introduction: Who We Are

We are a lean, product-based startup building the next generation of industrial robotics. Our products are deployed in critical, high-stakes environments, including Railways, Oil & Gas, Chemicals & Fertilizers, and Offshore operations.

We are not just writing code; we are building rugged, intelligent machines that operate in the real world.

1. The Mission (Pure Backend Focus)

You will architect the high-performance C++ Backend of our robotics software.

• No UI Work: You will NOT be designing UI pixels or writing QML front-end code.
• The Engine: Your mission is to build the “invisible engine” that processes 50 Mbps of raw scientific data and feeds it efficiently to the UI layer.
• Ownership: You own the threads, the data structures, and the logic.

2. Critical Outcomes (The First 4 Months)

• Architect the Data Ingestion Layer:
• Design a C++ backend capable of ingesting 50 Mbps of live sensor data (from embedded hardware) without dropping packets or consuming excessive CPU.
• Decouple Backend from UI:
• Implement Ring Buffers and Lock-Free Queues to separate high-speed data acquisition threads from the main Qt Event Loop, ensuring the backend never freezes the UI.
• Crash-Proof Concurrency:
• Refactor the threading model to eliminate Race Conditions and Deadlocks using proper synchronization (Mutexes/Semaphores) or lock-free designs.
• Efficient IPC Implementation:
• Establish robust Inter-Process Communication (Shared Memory / Sockets) to allow the C++ backend to exchange data with other Linux processes instantly.

3. Strategic Outcomes (Months 5 Onward)

As the product matures, your focus will shift from “Building the Engine” to “Hardening and Scaling the Ecosystem.”

• Robust OTA & Redundancy:
• Implement Linux A/B Partitioning strategies. You will design the fallback mechanism where the system uses atomic updates to revert to the last known good configuration in case of an update failure, ensuring high availability in remote offshore locations.
• Containerized Deployment:
• Move from manual builds to automated deployment. You will containerize the application (Docker / Podman) and integrate it with Jenkins / GitLab CI to enable seamless remote deployment to the robot fleet.
• Remote Diagnostics Engine:
• Build the internal logic to capture, compress, and transmit critical system logs and core dumps securely to the cloud without saturating the robot’s bandwidth.
• Fleet Monitoring Infrastructure:
• Distinct from simple logging, you will architect the heartbeat and telemetry protocols that allow our central command to monitor the health of robots deployed in railways and chemical plants in real time.

4. Competencies (Must-Haves)

• Qt Core (Backend Only):
• Expert in QObject, QThread, QEventLoop, and Signal/Slot mechanisms. You understand how to push data to QML, but you don’t style it.
• High-Performance C++:
• You handle data at the byte level, preferring Circular Buffers (Ring Buffers) over standard vectors for streams.
• Concurrency Mastery:
• You know when to use Lock-Free programming to avoid thread contention and can manage interactions between Data Acquisition and Processing threads without bottlenecks.
• Design Patterns:
• Competence in Producer-Consumer (for streams), Singleton (hardware managers), and Factory patterns.
• Linux System Programming:
• Comfortable with IPC (Shared Memory, Unix Domain Sockets) and optimizing process priorities.

5. The “Squad” (Your Team)

• Embedded Engineers:
• They push the raw 50 Mbps stream to the OS; you write the drivers to catch it.
• UI / Frontend Developers:
• They handle QML / UX; you provide the data APIs they need.
• Robotics (ROS) Engineers:
• You ensure their heavy algorithms don’t starve your data acquisition threads.
• Testers:
• You ensure your code stands up to their stress testing.

6. Why This Role Defines Your Career

• Deep Backend Engineering:
• Escape the “button styling” trap. This is 100% logic, memory management, and architecture.
• Real Engineering Problems:
• Solve race conditions, memory leaks, and high-velocity data streams.
• Architectural Autonomy:
• You decide how the data moves and choose the patterns. You own the “Engine Room.”

The One-Line Mission

You are the Chief Architect of the Robot’s Brain. You are not just writing a module; you are engineering the Complete Production Application that runs on the robot. You define how the system boots, how it manages state, and how it integrates the Robotics Team's ROS-based logic into your high-performance C++ Core without sacrificing speed or safety.

What You Will Engineer (The Complete System)

1. The "Drishti-OS" Application Framework (Core Architecture)

• The Challenge: This is a mission-critical, real-time application running in an explosive zone.
• Your Job: You design the Main Application Lifecycle.
• State Machine: You define the strict logic for the robot's states (e.g., Booting $\rightarrow$ Self-Check $\rightarrow$ Ready $\rightarrow$ Scanning $\rightarrow$ Emergency Stop).
• The ROS Bridge: The Robotics Team uses ROS Middleware for navigation. You architect the efficient Inter-Process Communication (IPC) bridge that allows their ROS nodes to talk to your Real-Time C++ Core without introducing latency into the critical data path.
• Resource Management: You ensure the CPU/RAM are allocated efficiently so the "Data Pump" never starves, even while ROS is calculating trajectory.

2. The "Data Engine" (Ingestion, Sync & Calculation)

• The Challenge: High-velocity data (730 mm/s) meets precise location tracking.
• Your Job: You build the central engine that:
• Ingests: 128 channels of Ultrasonic data via the AFM API.
• Syncs: Merges this data instantly with the ROS-published coordinates (X, Y, Theta) from the Robotics Team.
• Processes: Runs the C++ "Stitching Algorithm" to map raw signals into a coherent buffer for the UI.

3. Production-Grade Safety & Watchdogs (The "Safety Net")

• The Challenge: We operate in explosive refineries (Zone 1).
• Your Job: You implement the Software Safety Watchdogs required for ATEX certification.
• System Health: Your code monitors the heartbeat of the ROS nodes. If the Robotics logic freezes, your architecture must trigger a safe emergency stop immediately.
• Hardware Safety: You monitor internal pressure and motor temperatures, overriding control loops if physical limits are breached.

4. Data Persistence (The Digital Twin Source)

• Your Job: You own the .DRISHTI binary file format. You ensure that what we write to the disk is a corrupt-free, memory-mapped exact replica of the inspection, ready for the Full Stack Team to ingest.

5. The "Immortal" Deployment Architecture

• Your Job: You define how the code gets to the robot. You architect the OTA (Over-The-Air) System with Atomic Rollbacks. If a new update fails to boot, your architecture ensures the robot automatically reverts to the previous working version.

Who You Will Interact With

You sit at the center of the engineering circle:

1. Robotics Engineers (ROS Team):

• They do: They use ROS (Robot Operating System) middleware to build the robot's kinematics, navigation, and control logic.
• You do: You provide the architectural framework they plug into. You ensure their ROS messages (Pose/Odom) are consumed efficiently by your Core System.

1. UI/UX Developer (Qt/QML):

• They do: They build the visual dashboard.
• You do: You provide the Backend API and Signals to drive their interface.

1. Full Stack Developers (Cloud):

• They do: They build the customer-facing Reporting Platform.
• You do: You define the .DRISHTI File Contract so they can perfectly parse the data you save.

The Tech Stack You Architect

• Core: Modern C++ (17/20) (Smart Pointers, Move Semantics).
• Integration: ROS / ROS2 (Subscribers, Publishers, Custom Messages).
• Framework: Qt 6 Core (Event Loop, State Machine Framework).
• OS Level: Linux System Programming (Systemd, Kernel Tuning, Watchdogs).
• Architecture: Multi-threaded Producer-Consumer, Lock-Free Buffers, Shared Memory.

We're hiring at Octobotics! You will be a member of our robotics team. As a Robotics Engineer Intern, you will be responsible for engineering solutions to automation problems alongside the product development team. You can expect to co-craft innovative automated solutions and interfaces with C++/python, test third-party embedded modules in real-world scenarios, and use these experiences to pioneer the company's pioneering robotics platforms. 

The candidate should have above-average Linux skills. With experience using ROS and a comprehensive grasp of robotics fundamentals, the candidate should be able to deliver efficient and reliable code. The candidate should be able to work with vision systems and hardware like motor and controller systems, sensors, microcontrollers, communication protocols such as Ethernet or Modbus.

The candidate must be comfortable working in a dynamic environment with prototypes arising mid-project, and the discovery of new areas requiring attention at any given time is required.

Ways To Stand Out From The Crowd: 

• A Bachelor's degree in Robotics, Computer Science, Mechanical Engineering, or Electrical Engineering.
• Understand Computer Fundamentals - Compilers, linkers, Cmake.
• Understand DSA - Topcoder, CodeChef, HackerRank.
• SLAM ( Graph SLAM, Lidar based Localization )
• Use Rviz & Gazebo.
• Use Git - Add, Commit, Push. 

About Us:

We are working on next-generation maritime and aerial robotics for the future. We are developing the first Marine & Aero Robotic Platform in the World with Modular Manipulators for Autonomous Inspection & NDT even on heavily corroded surfaces (Matured Technology)/Eddy Current/Other NDT Techniques. We are a close-knit group of dreamers and doers who are willing to take risks, think outside the box, and try to accomplish the seemingly impossible.

We are ready to push the boundaries and are looking for people who want to be a part of this exciting journey. We may not promise the moon, but we will try our best to provide a conductive, non-toxic environment within a flat organization where "Every Opinion Matters." 

Octobotics Tech raised its pre-Seed round from a Hong Kong-based investor and is now hiring our very first few members of the Octobotics Tech family.

Octobotics is currently recruiting! You'll be working as part of our software development team. As a Full-Stack developer, you'll be working on web application development. We need your talent, collaboration, and energy to help us do big things that will inspire people all across the world. We need your innovative ideas and various backgrounds to help us imagine, create, and deliver systems that will benefit people. We are passionate about what we do, and we want you to be a part of our team as we take on new challenges at Octobotics Tech.

The full-stack developer for robotics will be:

• Collaborating with other developers on the UI's integration with new and existing hardware platforms.
• As needed, carry out other duties.
• Visualize live and simulated data.
• Develop real-time browser-based applications to support the design and development.
• In a collaborative atmosphere, you will create smart, elegant, and helpful software user interfaces and experiences for workstations.

Qualifications: required education, experience, or skills:

• Bachelor's degree in computer science, computer engineering, or related field of study, or comparable experience
• Expertise in creating user-facing software specifications and adhering to graphical specs
• Expertise with design software such as Sketch, Adobe XD, Figma, and others.
• 3 years of full-stack programming experience with Unity or QT Creator is required.
• Full-Stack design principles are well understood.
• Synthesizing function requirements into logical wireframes is something you've done before.
• The ability to work on a variety of robotic platforms
• Hands-on experience in using Node. JS, npm, Git, TypeScript, ExpressJS, Angular 10 and up, Angular Server-Side Rendering (Angular Universal)

Requisition Preferences:

• Front-end and back-end development for a web-based robotics system.

Why Work on Our Team?

We are working on next-generation maritime and aerial robotics for the future. We are developing the first Marine & Aero Robotic Platform in the World with Modular Manipulators for Autonomous Inspection & NDT even on heavily corroded surfaces (Matured Technology)/Eddy Current/Other NDT Techniques. We are a close-knit group of dreamers and doers who are willing to take risks, think outside the box, and try to accomplish the seemingly impossible.

We are ready to push the boundaries and are looking for people who want to be a part of this exciting journey. We may not promise the moon, but we will try our best to provide a conductive, non-toxic environment within a flat organization where "Every Opinion Matters."

Octobotics Tech raised its pre-Seed round from a Hong Kong-based investor and is now hiring our very first few members of the Octobotics Tech family.