Senior Backend Engineer

Senior Backend Engineer - Perpetual/Derivatives Platform (SunCrypto)

Jaipur (on-site) | 4–8 years

We are building India's next-generation crypto derivatives venue: a perpetual futures platform where every microsecond, every satoshi and every state transition has to be right. We're hiring a senior backend engineer to own the core of that system.

About SunCrypto

SunCrypto is an FIU-IND registered Indian cryptocurrency exchange (Angelic Infotech Pvt. Ltd., FIU registration VA00031314), headquartered in Jaipur. We run a regulated spot exchange serving Indian retail and institutional customers, and we are now expanding into derivatives, starting with perpetual futures built in-house by a small, senior engineering team that reports directly to the CTO.

We operate under the Prevention of Money Laundering Act and India's VDA tax regime. That shapes how we engineer: auditability, reconciliation and exactly-once accounting are product requirements, not afterthoughts.

The role

You will design, build and operate the backend services behind our perpetual futures product: the order lifecycle, position and margin engine, real-time market data fan-out, liquidity and hedging integrations with global venues, and the ledger that ties it all together.

This is a hands-on senior individual-contributor role with real architectural ownership. You will write code most days, review the code of others, be on the on-call rotation for the systems you ship, and be trusted to make technical decisions that a CTO would otherwise have to make.

The problems are hard in the way exchange problems are hard: hot paths that cannot block, balances that must never drift, and a market that never closes.

What you will own

Order and position engine

• Design and implement the order lifecycle for perpetual contracts, placement, matching hand-off, partial fills, cancels, amendments - with strict sequencing and deterministic replay.
• Build the position, margin and PnL engine: mark price, funding rate application, maintenance margin checks, liquidation triggers and insurance-fund logic.
• Model order books and state in Redis (sorted sets, Streams, Lua-scripted atomic operations) and persist authoritative state in MySQL 8 with correct isolation and locking.

Financial correctness and the ledger

• Implement a double-entry ledger with decimal arithmetic end-to-end, no floating point anywhere near money.
• Guarantee idempotency and exactly-once semantics across order, fill, funding and transfer events, including crash-recovery and replay.
• Build reconciliation jobs that prove our books balance against external venues, wallets and internal accounts, every hour of every day.

Real-time market data and connectivity

• Scale our WebSocket layer (ws / uWebSockets.js) to tens of thousands of concurrent connections: sharding, heartbeats, reconnect semantics, message batching and per-client backpressure.
• Own REST and WebSocket integrations with Binance, Bybit and OKX futures APIs — signed requests, rate-limit budgets, failover and staleness detection, for pricing, liquidity and hedging.

Reliability and operations

• Run what you build: Docker, Nginx, PM2 on Linux, with Prometheus / Grafana dashboards, alerting and structured logs that make 3 a.m. incidents debuggable.
• Write load tests and chaos scenarios for the hot path; define SLOs for latency and availability and hold the system to them.
• Raise the engineering bar through design reviews, code reviews, runbooks and mentoring of mid-level engineers.

Core stack : what we expect you to know cold

• Node.js 20+: deep async internals, event loop, worker threads, clustering, backpressure handling
• MySQL 8: transactions, isolation levels, row locking, deadlock handling, partitioning, replication, query tuning
• Redis 7: Lua scripting for atomic ops, Streams, Pub/Sub, sorted sets for order books, cluster mode, persistence trade-offs
• WebSockets: scaling ws / uWebSockets.js, connection sharding, heartbeat and reconnect, message batching
• Financial correctness: decimal arithmetic (never floats), idempotency, double-entry ledgers, exactly-once processing
• Concurrency: race conditions, distributed locks, optimistic vs pessimistic locking, sequencer patterns
• APIs: REST + WS integration with Binance / Bybit / OKX futures APIs, rate limits, signed requests
• Ops: Linux, Docker, Nginx, PM2, Git, monitoring (Prometheus / Grafana), structured logging

Must have

• 4–8 years of professional backend engineering, with at least 2 years on systems where correctness under concurrency was a hard requirement (payments, trading, ledgers, inventory, booking).
• Expert-level Node.js (20+) in production: you can explain the event loop, libuv thread pool, worker threads and clustering from first principles, and know when each is the wrong tool.
• Strong MySQL 8: you have chosen isolation levels deliberately, debugged a deadlock from the InnoDB status output, and tuned a query plan that mattered.
• Production Redis beyond caching: Lua scripts, Streams or Pub/Sub, and a clear view of AOF / RDB persistence trade-offs.
• You have built or scaled a real-time WebSocket service and dealt with the failure modes: slow consumers, reconnect storms, message ordering.
• Fluency with financial-grade correctness: decimal libraries, idempotency keys, double-entry accounting, exactly-once processing.
• Comfortable on Linux with Docker, Nginx, PM2, Git and a monitoring stack; you have been on call and improved the thing that paged you.
• Clear written and verbal communication: design docs, incident write-ups and pull-request descriptions that others can act on.
• Based in, or willing to relocate to, Jaipur.

Good to have

• Rust or Go: the ability to read and contribute to a Rust/Go matching engine or risk service is a strong plus.
• Domain background: prior work at a crypto exchange, broker, prop desk, or a stock-broking / derivatives firm.
• Event pipelines: Kafka, NATS or RabbitMQ for trade, fill and ledger event streams.
• Analytical stores: ClickHouse or TimescaleDB for trade, candle and PnL analytics.
• Infrastructure as code: Kubernetes and Terraform.
• Quant exposure: market making, delta-neutral hedging or options pricing.
• Open-source contributions or public writing on distributed systems, databases or trading infrastructure.

How we work

• Correctness first, then latency, then features. A slow trade is a bug; a wrong balance is an incident.
• Small, senior team. No layers between you and the CTO. Decisions are made in design docs and reviews, not meetings.
• You ship it, you run it. Engineers own their services in production, with a humane on-call rotation.
• Regulated, and proud of it. We build for auditors as well as traders. Every state change is traceable.
• Growth. Derivatives is SunCrypto's biggest bet. Engineers who build the first version will lead the teams that scale it.

Interview process

We aim to complete the process within two weeks and give feedback at every stage.

1. Intro call (30 min): your background, our roadmap, mutual fit.
2. Technical deep-dive (60–75 min): Node.js internals, MySQL transactions and locking, Redis atomicity, WebSocket scaling. Conversation, not trivia.
3. Take-home or pair-programming exercise: a scoped problem from our domain, reviewed together.
4. System design (60 min): design a slice of a perpetual futures platform end-to-end and defend the trade-offs.
5. Founder conversation with the CTO and CEO on ownership, ambition and how you want to grow.

Compensation: competitive, benchmarked to senior fintech roles.

Location: Jaipur, Rajasthan (on-site / hybrid). Full-time.

When you apply, include a link to code you are proud of (GitHub, a write-up, or a system you shipped) and two or three lines on the hardest concurrency or correctness bug you have fixed.