Polymarket Crypto 15mins Trading Bot

Polymarket Automated Trading Bot (Market Making + Statistical Arbitrage) — Polygon

Overview

I’m hiring an experienced automated trading developer to build a production-grade Polymarket trading bot (Polygon network). The bot will combine:

• Continuous market-making (two-sided quoting / spread capture)

• Model-driven statistical arbitrage (trade only when odds are meaningfully mispriced vs a fair-probability model)

Primary focus is short-dated crypto Up/Down prediction markets, especially BTC 15-minute markets (and optionally ETH/SOL/XRP).

This is not a liquidity-only bot. The goal is sustained profitability with disciplined risk management.

Strategy Requirements

A) Market Making (Core)

• Maintain two-sided quotes (YES/NO) on selected live order books

• Dynamic real-time updates:

  • Spread adjustment

  • Inventory skew / rebalancing

  • Liquidity-aware quoting (don’t quote into empty books)

• Works across at least 3 live markets simultaneously

B) Statistical / Model-Based Trading (Core)

• Stream real-time crypto price data (BTC mandatory; ETH/SOL/XRP optional)

• Compute rolling short-term volatility (e.g., rolling standard deviation)

• Compute fair probability using:

  • Price

  • Volatility

  • Time-to-expiry

• Execute trades only when edge ≥ configurable threshold

• Optional: support multiple probability models (baseline + improved)

Polymarket / Polygon Integration (Required)

Must support:

• Discover/read active markets + expiry metadata

• Fetch real-time odds + full order books

• Submit / amend / cancel orders programmatically

• On-chain execution with:

  • gas-awareness

  • retry logic

  • nonce management

  • rate limiting / backoff

• Robust error handling (RPC outages, partial fills, stale books)

Risk Management (Mandatory — Non-Negotiable)

The bot must never risk the full balance.

Required controls:

• Max exposure per market

• Position sizing rules

• Inventory limits + rebalancing logic

• Max trades per minute

• Liquidity/spread validation before placing orders

• Cooling-off logic (halt trading after unusual behavior, losses, or errors)

• Gas usage caps (per hour/day) + stop conditions

• Kill switch (manual + automated triggers)

• Paper trading / demo mode must respect all risk limits too

Deliverables

1. Production-ready bot

   • Python preferred (clean modular code)

   • C++/Rust acceptable if paired with a Python config layer or equivalent

2. Config system

   • YAML/JSON/TOML file is fine (light UI optional)

3. Paper trading / demo mode

4. Logging + monitoring

   • Trades, PnL, inventory, fills, order lifecycle, gas usage, errors

   • Optional: Prometheus/Grafana or simple dashboard

5. Telegram alerts (preferred)

6. README

   • setup, keys/wallet handling, deployment, troubleshooting, runbooks

7. Basic test suite + reproducible environment

   • Docker preferred

Acceptance Criteria (Must Pass)

• Runs unattended for 48 hours

• Quotes at least 3 live markets

• Quote updates consistently within milliseconds (or the fastest feasible given API/RPC constraints—must be optimized and measured)

• Properly respects all risk limits (no runaway trading)

• Produces net positive PnL after fees + gas in live trading (or clearly-defined paper trading benchmarks if you want this tested first)

Ideal Candidate

• Proven experience building automated trading systems (market making/HFT/arb)

• Familiar with:

  • prediction markets

  • option-style probability modeling / volatility-based pricing

  • on-chain execution (Polygon)

  • strong engineering discipline (observability, fault tolerance, testing)

When you apply, include:

• Examples of prior trading bots/systems (screenshots, repo snippets, architecture diagrams—anything you can share)

• Your proposed architecture (data feed + execution + risk engine + monitoring)

• Expected latency constraints and how you’ll hit them

• How you’ll handle: partial fills, stale odds, RPC failures, gas spikes, and slippage

Suggested Milestones (for better project control)

1. Architecture + skeleton repo (config/logging + market discovery)

2. Read-only mode (market data + order book streaming + pricing model)

3. Paper trading mode (PnL + inventory + risk limits)

4. Live execution (small caps + full safety controls)

5. Market making + model arb combined (tuning + monitoring)

6. 48-hour unattended run + final documentation