Naz V

Trading engine for Polymarket's 5 and 15-minute BTC up/down markets, in Rust and Python. Designed, built and ran it in production with my own capital.

• Edge: these markets settle on a Chainlink oracle price, which reached the market ~1.2 s behind Binance (median; 1.8 s p95). Priced every contract off Binance instead, so my fair value moved a second or two before anyone pricing off the oracle feed.
• Pricing: each market is a cash-or-nothing digital option, so P(up) = Φ(d₂) under geometric Brownian motion, with volatility from a rolling 10-minute window of 1 s Binance returns and the strike taken from the oracle price at the window open. A nowcast projects the next oracle print from Binance micro-price moves, with the beta fitted online by exponentially weighted least squares.
• Pipeline: Rust (tokio) collectors for Binance L2 depth, the Polymarket order book and the oracle feed drive an L2 book state machine and a streaming feature engine. Output goes to a Python asyncio/uvloop strategy engine over a Unix domain socket as length-prefixed binary frames.
• Execution and risk: fill-and-kill taker orders sized by fractional Kelly on edge after fees, with per-market and global exposure caps and gates for stale books and the last seconds before expiry. An expected-value rule decides whether to hold, sell or buy the other side. Fills arrive over the user WebSocket channel and are reconciled against exchange and on-chain balances. Positions are merged and redeemed on-chain through a Gnosis Safe.
• Research: tick-level backtester with the exchange fee curve, fills against real book depth and capacity limits. Oracle data is indexed by receive time, not the oracle's own timestamp, which keeps a ~1 s lookahead out of the results. Also tested an XGBoost and Bayesian regression ensemble on 193 streaming order-book features, with the Rust feature engine checked against the Python research code by golden-vector tests.
• Production: Docker Compose, a latency benchmark of every exchange endpoint for choosing the server location, Prometheus histograms on the hot path, Grafana dashboards, Loki logs with one run ID shared by the Rust and Python processes, config hot-reload without restarts and real-money integration tests on Polygon mainnet.

High-frequency trading engine in Rust. Designed, built and ran it in production with my own capital.

• 50 µs / 150 µs p50 / p99 tick-to-trade (market data in to order sent). Consistently landed transactions ahead of 99% of competing bots. 70% leader inclusion. $500k traded.
• Market data: low-latency shred ingestion and reconstruction (deshredding) with multiplexed receivers to cut data-receive latency.
• Order path: durable-nonce, multi-path routing through independent providers, plus direct-to-leader submission. Co-located with the majority of validator stake to cut propagation and leader-path latency.
• Latency and correctness: CPU pinning for critical threads; asynchronous, non-blocking logging; periodic RPC/account diff checks that detect and repair state desync.
• Strategy: open positions managed by a hazard (survival) model that makes the exit decisions. A real-time sidecar indexer computes custom risk metrics and features.

NFT rentals protocol. Raised $6.5m (pre-seed and seed) from investors including Animoca Brands, OpenSea and Gemini.

• Tested the idea in 5+ hackathons and won prize money in every one. The winnings paid for the first hires.
• Built three generations of the rental protocol on EVM: collateralized (code), collateral-free, and smart-wallet-based, where the renter receives the NFT in their own wallet and on-chain access controls limit what they can do with it.
• Partnered with the studio behind Castle Crush (50m+ downloads), which led to 500k+ on-chain rentals.
• Led a team of 5 engineers at peak. Shipped fast experiments (github.com/re-nft), such as renter rights for CryptoPunks (code), which received media coverage.
• Pivot: built an early pump.fun competitor in 4 weeks with two other engineers (announcement).

NFT-powered 3v3 basketball mobile game (iOS, Android). Raised $6.5m+ from investors and NBA players including Stephen Curry and Paul George.

• NFT collection traded $70m+ (20k+ ETH) on-chain. $5m+ revenue from contracts deployed and royalties.
• Zero smart contract bugs across every contract shipped. The mint ran without problems and our services were known for reliability.
• Approached by The Sandbox's CMO to deliver the NFT collection and the tech for the game.
• First collection to offer on-chain NFT renaming. Built an on-chain marketplace (code).
• Led a team of 5 engineers at peak.

Market-making bot in Python. Designed, built and ran it in production with my own capital.

• ~$500k monthly volume on ~$1k capital (~17x daily turnover). Realized 10 bps after fees. Median 30 s mark-out +2 bps. Inventory held within ±20%.
• Concurrent multi-threaded engine: WebSocket/REST I/O, quoting, execution, monitoring and logging, with clean, fault-tolerant shutdowns.
• Kept a local L2 order book from snapshots and incremental updates, used for depth, spread and mark-out calculations.
• Adaptive quoter prices at meaningful depth in the book and slows or pauses during reconciliation or heavy execution to avoid desync.
• Execution layer with WebSocket-to-REST fallback, retries with randomized backoff and sizing based on capital. State manager mirrors balances in real time, recovers dropped trade messages through REST polling and persists net fills and P&L to DynamoDB.
• Risk controls: spread, volatility, volume and drawdown thresholds switch the engine between TRADE / WAIT / STOP and flatten positions automatically when a limit is breached.
• Production: CI/CD on CircleCI, Docker, AWS ECR/ECS, runtime secrets in SSM, CloudWatch logs, DynamoDB configs and backups with point-in-time recovery.

Wealth management firm.

• Built a multi-asset risk-factor decomposition model. It measures a portfolio's sensitivity to each risk factor and simulates historical stress events against the portfolio's current exposures (demo).
• Built the firm's internal quant tools in Python (demo).
• Promoted after one year.

Systematic investment fund that came out of UCL. First graduate hire, on a team of three (CTO, head quant, me).

• Owned the stock pre-screening stage of the strategy and all data handling. Built every data processing pipeline.
• Built a Python portfolio analysis tool that produces PDF reports on returns and portfolio composition.
• Joined as an MSc intern, was offered a full-time role, promoted after 6 months. Supervised a machine learning intern and interviewed new hires.