Urgent Requirement For Rust Developer with 63MT

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

Job summary

63moons is seeking a seasoned Senior Rust Engineer to architect and build vital backend subsystems like order and risk engines in Mumbai. You will drive low-latency, high-throughput behavior with concurrency and robust system design for production workloads.

The role emphasizes designing core engine components, optimizing performance, and mentoring on architectural decisions while embedding security and risk controls across critical paths. Exposure to fintech or trading domains is highly valued.

Qualifications

• 3+ years of hands-on Rust experience.
• Strong systems-level programming skills with asynchronous patterns.
• Proven ability to build performance-critical components (order matching, risk assessment, or similar).
• Solid understanding of data structures and algorithms.
• Experience with cache-friendly data layouts, memory locality, and false sharing.
• Familiarity with SIMD/vectorization and modern CPU instruction sets for performance.
• Experience with zero-copy designs, memory pooling, and minimizing allocations.
• Strong knowledge of lock-free/low-lock concurrency and atomics.
• Exposure to fintech, trading, or low-latency services is valued.
• Experience with profiling and benchmarking tools (perf, flamegraphs, criterion) is a plus.

Responsibilities

• Design and develop core engine components for workflows and constraints.
• Optimize for concurrency, performance, and reliability in high-throughput paths.
• Benchmark, profile, and optimize high-throughput workloads.
• Guide design reviews and maintain code quality across the team.
• Embed security and risk controls in system components.
• Design systems with predictable latency under production workloads.
• Identify and mitigate performance bottlenecks related to CPU caches and memory contention.

Skills

Rust

Systems programming

Asynchronous programming

Memory safety

Order matching

Data structures & algorithms

Data-oriented design

Lock-free concurrency

Tokio/Actix

Profiling

Zero-copy

SIMD

Performance benchmarking

Tools

perf

Flamegraphs

Criterion

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.