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 professional 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.