Urgent Requirement For Rust Developer with 63MT

63 moons; Mumbai; On-site; INR 4,000,000 - 7,000,000; Full time

Job summary

63 moons in Mumbai is seeking a seasoned Rust engineer to architect and build vital backend subsystems, including order and risk engines. You will drive low-latency, concurrent processing and robust systems for high-throughput trading workflows.

You will guide design reviews, optimize performance, and embed security controls across services. The role demands strong systems programming, memory-safe Rust, and experience with async runtimes like Tokio or Actix.

Qualifications

• Hands-on Rust experience in systems-level programming.
• Strong knowledge of asynchronous patterns and memory-safe design.
• Experience building performance-critical components such as order matching or risk engines.
• Solid understanding of data structures and algorithms.
• Familiarity with cache-friendly, data-oriented coding practices.
• Experience with SIMD/vectorization and modern CPU features.
• Knowledge of zero-copy design, serialization, and memory pooling.
• Understanding of lock-free/concurrent primitives and memory ordering.
• Exposure to fintech, trading, or low-latency services is valuable.

Responsibilities

• Design and develop core engine components to orchestrate workflows and enforce constraints.
• Optimize for concurrency, performance, and reliability in high-throughput paths.
• Benchmark, profile, and optimize high-throughput workloads.
• Lead architecture reviews and uphold code quality across the team.
• Embed security and risk controls into system components.
• Design systems with predictable latency and high throughput under production workloads.
• Identify and mitigate bottlenecks related to caches, memory bandwidth, and synchronization.

Skills

Rust

Systems programming

Async/await

Performance optimization

Concurrency

Zero-copy design

Lock-free programming

Tokio/Actix

Profiling tools

Multithreading

Tools

Tokio

Actix

Perf

Flamegraphs

Criterion

LLVM

Job description

Senior Rust Engineer 5+ Years (Systems, OMS & Risk Logic)

Location: Mumbai

Employment Type: Full-time

Role Overview

We are seeking a seasoned Rust engineer to architect and build vital backend subsystems like order and risk engines. You will be instrumental in driving low-latency behavior, concurrency, and system robustness in high-throughput scenarios.

Key Responsibilities

• Design and develop core engine components responsible for orchestrating workflows and enforcing system constraints.
• Optimize for concurrency, performance, and reliability in critical transaction paths.
• Conduct rigorous performance benchmarking, profiling, and optimization of high-throughput workloads.
• Guide technical design, architecture reviews, and uphold code quality standards across the engineering team.
• Embed security and risk controls directly into system components, ensuring adherence to engineering safety standards.
• Design systems with predictable latency and high throughput under sustained production workloads.
• Identify and eliminate performance bottlenecks involving CPU caches, cache-line contention, false sharing, branch misprediction, memory bandwidth, and synchronization overhead.

Qualifications

• Minimum 3 years of hands-on experience in Rust.
• Mastery of systems-level programming, asynchronous patterns, and memory-safe architectures.
• Solid experience building performance-critical components especially in order matching, risk assessment, or equivalent systems.
• Solid understanding in Datastructures and Algorithms.
• Experience writing cache-friendly and data-oriented code, with an understanding of memory layout, data locality, alignment, and false sharing.
• Familiarity with SIMD/vectorization and techniques for leveraging modern CPU instruction sets for performance-critical workloads.
• Experience with zero-copy designs, efficient serialization/deserialization, memory pooling, and minimizing allocations.
• Strong understanding of lock-free / low-lock concurrency, atomics, memory ordering, and synchronization primitives.
• Deep familiarity with async runtimes (e.g., Tokio, Actix) and multithreading models.
• Previous exposure to fintech, trading, or other low-latency, high-reliability services is highly valued.
• Experience with profiling and benchmarking tools such as perf, flamegraphs, and criterion is a plus.