Python Solutions Engineer DUBAI

Job Description

Summary

This applied research facility transforms theoretical AI into practical tools for aviation, healthcare, and logistics, with a core focus on advanced robotics. By prototyping everything from autonomous airport robots to smart medical equipment, it serves as a high-tech engine for urban evolution. The lab bridges the gap between academic ideas and industrial needs, empowering local experts to build robotic systems that redefine how a modern city moves and operates.

General Information

The position is open to full-time candidates with excellent communication skills located in the UAE.

Why this role exists

Nebula is a vendor-agnostic automation orchestration platform that gives enterprises a single control plane for heterogeneous robot fleets. We've built the MVP: orchestration engine, visual workflow canvas, real-time telemetry, edge-cloud hybrid architecture, and validated the thesis with integration partners (QuikBot).

We're now at the point where we need to start standing up real deployments, independent of our formal product launch timeline. These deployments serve a dual purpose: they activate our commercial pipeline, and they surface the gaps between our MVP and what production environments actually demand. Every gap this engineer discovers becomes a roadmap input. Every manual step they repeat becomes a candidate for productization.

This is the first GTM-facing technical hire. The role sits at the intersection of a Palantir Forward Deployed Engineer, a Google/Meta Business Engineer, and a Solutions Architect — someone who can scope a deployment, present to a client, write the integration code, configure edge hardware, and document what they learned so the platform gets better.

What you'll do

Deployment execution. Stand up Nebula at customer sites across three deployment models: SaaS multi-tenant, client cloud (Azure/AWS), and on-premises. This includes edge node configuration (NVIDIA Jetson, Intel NUC), MQTT/gRPC communication setup, Kubernetes/Helm packaging, and network configuration (Wi-Fi 6, private 5G).

Robot onboarding and integration. Bridge vendor-specific APIs to the Nebula platform. The primary gap today is robot onboarding — getting a new robot vendor's fleet connected and controllable through Nebula. A mitigation approach exists (developed internally at DFL via MVP integration work) that you'll apply and generalize to new hardware targets. You'll write Python/JS glue code, configure the connector layer, and validate end-to-end fleet control.

Technical discovery and scoping. Before code gets written, assess each deployment target: what's the customer's environment, what robots & IoT devices are they running, what does their network look like, what integration approach fits. Design the deployment architecture, scope the work, set expectations with the client. This is the Solutions Architect muscle: you're the one who turns a warm lead into a concrete deployment plan.

Client-facing communication. Present Nebula to both technical audiences (peer-level engineering and IT leaders) and non-technical decision-makers (operations VPs, C-suite) alongside the core Nebula DFL team. You'll need to help explain edge-cloud architecture to aCTO and single pane of glass for your robot fleet to an operations director, often in the same meeting.

Gap discovery and feedback loop. This is the part that makes the role strategic, not just operational. Every deployment teaches us something. You'll document what's missing, what's brittle, what customers ask for that we don't have. These findings feed directly into DFL's market map (which deployment types are viable today vs. which need dev work) and the product roadmap. You are the canary in the coal mine, and the canary needs to write good reports.

What you bring

Technical (must-haves)

• Python — primary language for integration scripts, API bridging, automation. You'll be writing glue code daily.
• JavaScript/TypeScript — Nebula's frontend is a React monorepo (React Flow canvas, Jotai state management). You'll need to configure workflows, debug UI issues in the field, and potentially extend the canvas for customer-specific needs.
• Containerization and orchestration — Docker, Kubernetes, Helm. You'll be packaging and deploying Nebula's microservices stack across different environments.
• Messaging and communication protocols — MQTT (robot telemetry), gRPC (cloud commands). This is the nervous system of the platform; you need to be comfortable debugging message flow between edge and cloud.
• Edge computing — Linux on embedded/industrial hardware (Jetson, NUC, or similar). You'll configure edge nodes that serve as the local bridge between robots and the Nebula cloud.
• REST/GraphQL API integration — you'll be consuming and bridging third-party vendor APIs(robot fleet managers, building management systems, IoT platforms).
• Infrastructure as code — Terraform, Ansible, or equivalent. Deployments need to be reproducible across environments.

Technical (bonus/preferred skills)

• ROS/ROS2 — understanding of the Robot Operating System ecosystem. Not all vendors use it, but it's the lingua franca of robotics middleware.
• Temporal — Nebula's orchestration engine uses Temporal for workflow persistence. Understanding durable execution patterns accelerates your effectiveness.
• Real-time video — LiveKit integration for robot camera feeds. Some deployments will require configuring video streaming pipelines.
• Network engineering — Wi-Fi 6 (802.11ax), private 5G slicing, VLAN configuration. Robot connectivity in warehouses and airports is a real deployment challenge.

What you won't do

Core platform engineering. You're not building the orchestration engine or the workflow canvas. Another team owns the platform. You use the platform's APIs, connectors, and tools to deploy it — and when those tools are insufficient, you file that feedback and write glue code to bridge the gap.

Pure sales or BD. Other stakeholders own pipeline and commercial relationships. You're the technical credibility in the room, not the deal closer. Think of it as: they get the meeting, you make it real.

Technology environment

Frontend

• React (monorepo, pnpm), ReactFlow, Jotai, Skia/Reanimated (mobile)

Backend

• Microservices, Temporal (workflow persistence), OpenRouter (LLM orchestration)

Communication

• MQTT over WSS (telemetry), gRPC (commands), LiveKit (video)

Edge

• NVIDIA Jetson / Intel NUC, Linux, MQTT broker

Infrastructure

• Docker, Kubernetes, Helm, Terraform

Connectivity

• Wi-Fi 6 (802.11ax), private 5G (planned)

Robot vendors (current)

• QuikBot (heavy/industrial, digital twin integration), Kiwibot (last-mile, B2B API)

Robot vendors (pipeline)

• Pudu Robotics, plus customer-specific hardware TBD