About the Role

The Software Engineer role at Partnerverse involves building low-latency, high-throughput trading infrastructure primarily in Rust. Candidates will work closely with senior systems architects, focusing on performance-critical systems through hands-on coding, testing, and optimization.

Responsibilities

Develop and maintain high-performance backend services in Rust under the guidance of senior engineers.
Implement components of distributed, fault-tolerant systems handling high transaction volumes.
Write extensive unit, property-based, and simulation tests for correctness-critical code.
Profile and optimize code for latency, throughput, and memory efficiency.
Participate in design discussions and rigorous code reviews.
Debug and resolve issues in Linux-based production environments.

Required Qualifications

B.Tech/M.Tech in Computer Science from an IIT or NIT (mandatory).
3+ years of professional software development experience in Rust, C++, or Java/Go with systems-level work; strong Rust proficiency or demonstrated ability to attain it fast.
Understanding of financial markets and trading systems — order books, order types, matching concepts, spot and derivatives (futures/options) basics; hands-on experience with trading, broking, or market data systems is a strong plus.
Excellent computer science fundamentals — data structures, algorithms, operating systems, networking, concurrency.
Solid grasp of multithreading and memory management; exposure to performance profiling and benchmarking.
Understanding of distributed systems concepts — replication, consistency, message queues (Kafka/NATS or similar).
Experience with Linux, Git, and modern development workflows.
Strong problem-solving ability and hunger to work on hard systems problems.

Preferred Qualifications

Competitive programming background (Codeforces/ICPC/CodeChef ratings welcome on the CV).
Personal or open-source Rust projects.
Exposure to low-latency techniques — lock-free structures, zero-allocation design, binary protocols (SBE/Protobuf/FlatBuffers).
NISM certifications, trading experience (personal F&O/options trading counts), or coursework in financial engineering.
Exposure to consensus algorithms (Raft), event sourcing, or deterministic testing.

Growth Path

You will be mentored directly by senior systems engineers with deep exchange-infrastructure experience, with a defined progression to senior engineer ownership of subsystems within 18–24 months. This team is being built as a center of excellence in low-latency systems engineering in India.

Selection Process

Resume shortlisting (college + evidence of strong engineering: projects, CP ratings, internships).
Online DSA + systems assessment.
Live coding round (Rust/C++, performance-oriented problem).
Systems and trading-concepts discussion round.
Culture and ownership round with the senior engineer you will report to.

Compensation

Top of market for the experience band, benchmarked against product companies, not services.

Requirements

Rust proficiency

Strong Rust proficiency or demonstrated ability to attain it fast is mandatory.

Systems-level experience

3+ years of professional software development experience in Rust, C++, or Java/Go.

Financial systems knowledge

Understanding of financial markets and trading systems is essential.

Computer science fundamentals

Excellent knowledge of data structures, algorithms, and operating systems is required.

Multithreading skills

Solid grasp of multithreading and memory management is necessary.

Nice to Have

Competitive programming

A background in competitive programming is a plus.

Open-source projects

Personal or open-source Rust projects are preferred.

Low-latency techniques

Exposure to low-latency techniques is beneficial.

NISM certifications

NISM certifications or trading experience is a strong plus.

Benefits

Mentorship

Direct mentorship from senior systems engineers.

Career progression

Defined progression to senior engineer ownership of subsystems.