Software Lead Engineer - Space Simulation (Space Domain)

Requirements

Orbital Mechanics and Astrodynamics

• Solid working knowledge of analytical orbit propagation — not just calling a library, but understanding what it computes, its accuracy envelope, and where it breaks down
• Hands-on experience with numerical orbit propagation using adaptive step integrators, with full perturbation models: atmospheric drag, higher-order gravity, solar radiation pressure, third-body effects
• Familiarity with standard orbit element formats, epoch handling, and the practical limits of catalogue-quality data
• Working knowledge of coordinate frame transforms and access to authoritative ephemeris sources
• Understanding of close-approach geometry and conjunction screening concepts
• Familiarity with empirical upper atmosphere models and their sensitivity to solar activity inputs

High-Performance Simulation Core (Compiled Language)

• Strong, recent hands-on experience in a compiled systems language (C++ preferred) writing numerically intensive code that must be correct first and performant second
• Shared-memory parallelism: threading models, race condition analysis, false sharing avoidance, thread-safe logging
• Memory layout design for cache-friendly access across large object populations
• Integration with third-party C scientific libraries without memory leaks or undefined behaviour
• Attitude representation: quaternion algebra, renormalisation, singularity avoidance — able to articulate from first principles why gimbal-lock representations are unacceptable in a simulation context
• Adaptive step integration: step acceptance and rejection logic, error estimation, handling of state variables that change continuously during propulsive events
• Spacecraft sensor and actuator modelling: understanding of the measurement chain from physical sensor to estimated state, and actuator dynamics including saturation behaviour

Scientific Data Pipeline

• Design and implementation of binary scientific data formats for large time-series datasets produced by long-running HPC jobs: incremental write patterns, crash safety, and reading partially written output from a concurrent consumer
• On-the-fly computation at query time over large catalogues — understanding the trade-offs between pre-computation and real-time evaluation
• Ground truth vs estimated state: designing a system where operators never see true simulation state, only what an estimation chain would produce from simulated sensor measurements

Application Backend

• Async server development: async/await patterns, event loops, long-lived connection management
• Server-Sent Events or equivalent push mechanisms: fan-out to multiple heterogeneous subscribers, backpressure handling, reconnection
• Managing long-running subprocesses from the backend: holding a subprocess handle, writing commands to its input, reading events from its output asynchronously, detecting and handling crashes
• Lightweight relational storage for operational metadata: schema design, migration strategy, single-writer concurrency constraints
• Role-based access control enforced at the API layer: route guards, token-based authentication, optional second-factor support in air-gapped environments
• Background scheduling within the application process: periodic external data refresh, job status polling
• Programmatic report generation (PDF): layout, tables, structured data rendering — not template-based

HPC Job Management

• Direct experience writing job scripts for a workload manager (SLURM or equivalent): resource allocation, node selection, job arrays
• Interactive vs batch job submission — knowing the operational difference and when each is appropriate
• Job lifecycle monitoring: status polling, sentinel-file-based completion detection, epilog handling
• Single-node multi-core parallelism within a job; understanding when intra-job distributed parallelism is unnecessary complexity
• Shared storage access from multiple compute nodes; filesystem coherency considerations
• Deploying scientific software on Linux HPC clusters: build systems, shared library management, packaging for the deployment OS

Native Desktop Client and 3D Rendering

• Native desktop application development (not web-based): signal/slot or equivalent event model, OpenGL integration via a widget, animation timers decoupled from simulation time
• Custom OpenGL rendering: vertex array objects, instanced geometry, batched buffer uploads, shader authorship — able to render tens of thousands of objects in a single draw call
• 3D Earth visualisation: geodetic ellipsoid rendering, instanced marker sprites, trajectory polyline batching, arcball or equivalent camera control
• Role-based panel visibility driven by login state within a single application — not multiple executables
• Desktop application packaging: producing an installer for analyst workstations with a configurable server address at install time

Build, Packaging, and Tooling

• Build system authorship for compiled code: dependency resolution, compiler flags, packaging for the target deployment OS
• Python environment and dependency management: deterministic lockfiles, reproducible environments across nodes
• Structured logging strategy: separating per-job logs from per-process service logs, human-readable and machine-parseable outputs, never sharing file handles across process boundaries

Benefits

We offer great career growth, ESOPs, Gratuity, PF and Health Insurance.