Role: Product Manager, Trading Infrastructure

You will own the professional and algo trading surface of Arrow: the products where latency, data depth and execution quality are the whole point. Five areas sit in your remit, and each one is a product in its own right.

- TBT charts: In-house tick-by-tick charting: sub-second candles, order-flow and footprint views, replay, with chart latency held close to feed latency
- HFT algos: In-house algos and a strategy marketplace retail traders can deploy on co-located infrastructure, with risk guardrails and exchange approvals built in
- API latency: The trading and market-data APIs: round-trip order latency at p50/p95/p99, WebSocket feed delivery, SDK ergonomics, rate limits, sandbox
- Colocation access: Productizing exchange co-lo for clients: rack and VM offerings, provisioning, cross-connects, pricing and compliance
- Tick-level data: Dissemination of full-depth, tick-by-tick market data: live feeds, snapshots, historical tick archives, entitlements and fan-out at scale

This is the first dedicated Product Manager on the Arrow team. You will work directly with the CTO, the HFT desk, the quant team and exchange-connectivity engineers, and you will set the product process as much as run it. Expect to spend as much time with latency histograms and order-book data as with roadmap documents.

You'll do:

- Own the TBT charting roadmap. Define what a tick-by-tick chart must do for a scalper that a one-second chart cannot: sub-second aggregation, order-flow and footprint views, volume-at-price, replay, and multi-instrument sync. Set and track the chart-update latency budget against the raw feed.
- Bring in-house HFT algos to retail. Scope the first algos and the strategy marketplace: which strategies ship first, how traders discover, configure and deploy them on co-located infrastructure, what the kill switches and position limits look like, and how each algo clears SEBI and exchange approval before launch.
- Own API latency as a product metric. Define the order round-trip and feed-delivery SLOs at p50, p95 and p99, instrument them end to end (client, gateway, OMS, exchange),



publish them transparently, and drive the engineering backlog that moves them.
- Run the developer experience for the trading API: Go and Python SDKs, WebSocket market-data streams, docs, sandbox, rate limits, static-IP and algo-tagging requirements, and onboarding for API clients from first key to first live order.
- Productise colocation access. Turn exchange co-lo into something a professional client can buy: rack, VM and managed-server tiers, provisioning SLAs, cross-connects, pricing, and the compliance and audit trail each exchange requires.
- Own tick-level data dissemination. Define the market-data products: full-depth live feeds, TBT versus snapshot tiers, historical tick archives, entitlements and billing, and the fan-out architecture needed to serve thousands of clients without adding latency.
- Talk to skilled traders every week: scalpers, option market-makers, quants and API users. Turn what they say and what their order flow shows into specs engineers can build from without a second meeting.
- Write crisp PRDs with success metrics, latency budgets, failure modes and exchange-rule constraints (algo approval, order-to-trade ratios, throttles, circuit limits, square-off timings) spelled out.
- Partner with the CTO, the HFT desk and exchange-connectivity engineers on trade-offs between latency, throughput, reliability and features; a feature that adds 200 µs to the hot path is a product decision, not just an engineering one.
- Define and track the metrics that matter: order latency and feed latency by percentile, API uptime, active API clients, algo deployments and their P&L; distribution, co-lo utilisation, and tick-data subscriptions.

What we're looking for:

- 4-8 years in product, trading-systems engineering or quant/HFT trading,



with at least 3 years owning a technical or fintech product end to end.
- You understand market microstructure. Order books, tick data, matching-engine behaviour, order-to-trade ratios, what co-lo buys you and what it does not. You know why a scalper cares about the difference between 1 ms and 3 ms.
- Hands-on with trading APIs. You have built or run something against a broker or exchange API, understand REST versus WebSocket versus binary protocols, and can read a latency histogram and say where the time went.
- Fluent with data. You can write SQL, pull your own latency and order-flow data, and argue a prioritisation call with numbers rather than opinions.
- Shipped in a regulated environment. You can read a SEBI or exchange circular on algo trading, API access or market data and turn it into a product requirement.
- Clear writer. Your PRDs, SLO definitions and API docs get read and acted on by engineers and traders alike.
- Bias for shipping. You have taken a feature from a trader complaint to production in weeks, not quarters, and iterated after launch.

Nice to have:

- Worked at an HFT or prop firm, an exchange, a market-data vendor or an algo trading platform.
- Familiarity with NSE/BSE TBT and snapshot feeds, exchange co-lo offerings and the NNF/API order-tagging framework.
- Have run a live strategy through a broker API, even a small one.
- Options knowledge beyond the basics: Greeks, market-making, hedged-position margin.
- Python or Go, enough to prototype an API call, parse a tick file or build your own latency dashboard.

What we Offer:

- A real execution edge to build on: co-located infrastructure and a 17-year HFT track record that no other retail broker in India starts with.
- First dedicated PM in the seat. You define the role, the process and the roadmap, and you report to the CTO.
- Direct access to the HFT desk, quant team and exchange-connectivity engineers; the people who built the engine sit a few desks away.
- Offices in Mumbai (Andheri East); market hours mean an early start and a clear end to the day.

📌 Product Manager (Mumbai)
🏢 Irage
📍 Mumbai