DEV Community

Benjamin-Cup
Benjamin-Cup

Posted on

How I Built an Inventory-Balanced Trading Strategy for Polymarket

#python #opensource #architecture #polymarket

Most trading bots focus on one question:

When should I buy or sell?

While building my latest Polymarket strategy, I found another question to be just as important:

What happens after the trade?

A signal is easy to create. Managing inventory, failed hedges, stale orders, and changing market conditions is much harder.

So I built the strategy around three main ideas:

  • Detect meaningful price movement
  • Execute trades in smaller cycles
  • Keep inventory and risk under control

The Basic Strategy

Polymarket markets have complementary outcomes such as:

YES
NO
Enter fullscreen mode Exit fullscreen mode

Instead of trying to predict which outcome will eventually win, this strategy looks for temporary pricing inefficiencies and manages both sides.

For example:

YES = $0.58
NO  = $0.49
Enter fullscreen mode Exit fullscreen mode

The strategy can attempt to exploit the relationship between the two sides while controlling execution and inventory risk.

I consider this closer to inventory-balanced trading than pure arbitrage.

1. Laddered Execution

Instead of executing a large position at once, the bot divides it into smaller cycles.

Example:

100 YES
100 NO

5 cycles
20 shares per cycle
Enter fullscreen mode Exit fullscreen mode

A cycle looks like:

Sell YES 20
     ↓
Wait for opposite side
     ↓
Sell NO 20
     ↓
Cycle complete
Enter fullscreen mode Exit fullscreen mode

This helps reduce execution impact and makes inventory easier to manage.

2. Momentum + Reversal Detection

The first version of the strategy reacted to simple price spikes:

if price_rise >= 0.03:
    execute_sell()
Enter fullscreen mode Exit fullscreen mode

That was too sensitive to short-term noise.

The updated strategy waits for:

Uptrend
   ↓
Local peak
   ↓
Reversal
Enter fullscreen mode Exit fullscreen mode

A simplified uptrend check:

def uptrend_detected(prices):
    return (
        prices[-6] <
        prices[-5] <
        prices[-4] <
        prices[-3] <
        prices[-2]
    )
Enter fullscreen mode Exit fullscreen mode

Then the bot checks whether a local peak has formed:

def peak_detected(prices):
    return (
        prices[-2] > prices[-3]
        and prices[-2] > prices[-1]
    )
Enter fullscreen mode Exit fullscreen mode

The trade is only considered when the movement is also strong enough.

3. Inventory Is the Important Part

Imagine the bot executes:

SELL YES
Enter fullscreen mode Exit fullscreen mode

but the opposite side never reaches the expected price.

Now the bot has an unbalanced position.

That is why the system tracks:

  • Current inventory
  • Completed cycles
  • Pending hedges
  • Time since first execution
  • Remaining market time

The strategy should always know exactly what position it has.

4. Hedge Protection

The bot doesn't wait forever for the perfect hedge.

For example, one protection rule can trigger when the opposite token stays below:

$0.20
Enter fullscreen mode Exit fullscreen mode

for:

15 seconds
Enter fullscreen mode Exit fullscreen mode

Another rule becomes active when the market approaches settlement.

With around:

20 seconds remaining
Enter fullscreen mode Exit fullscreen mode

the bot becomes more aggressive about closing the remaining position.

There is also a maximum hedge timeout:

60 seconds
Enter fullscreen mode Exit fullscreen mode

If the normal hedge hasn't happened by then, the system exits using a more aggressive limit price.

The principle is simple:

Every trading cycle needs an escape path.

5. Limit Orders + Stale Order Protection

The strategy uses limit orders to maintain control over execution price.

But limit orders can become stale.

So an unfilled order is cancelled after:

15 seconds
Enter fullscreen mode Exit fullscreen mode

The process becomes:

Submit
  ↓
Wait
  ↓
Filled?
 ├── Yes → Complete
 └── No  → Cancel → Re-evaluate
Enter fullscreen mode Exit fullscreen mode

This prevents old orders from remaining active after market conditions have changed.

6. Trading Window

The bot also limits when new cycles can start.

Current configuration:

trade_start_seconds: 300
trade_stop_seconds: 90

trend_strength_threshold: 0.03
first_leg_min_price: 0.50

force_hedge_opposite_price_threshold: 0.20
force_hedge_delay_seconds: 15

order_cancel_seconds: 15
hedge_timeout_seconds: 60
Enter fullscreen mode Exit fullscreen mode

These values are strategy parameters, not universal numbers. Different markets can behave very differently.

The Main Lesson

The biggest lesson from building automated prediction-market systems is:

The trading signal is only one part of the strategy.

A complete system needs:

Market Data
     ↓
Signal
     ↓
Execution
     ↓
Inventory
     ↓
Hedge
     ↓
Risk Control
Enter fullscreen mode Exit fullscreen mode

A good entry signal does not help much if the bot cannot manage what happens afterward.

That's why I increasingly think about trading bots as decision-making systems under uncertainty, rather than simply automated buy/sell scripts.

Resources

Polymarket Docs:
https://docs.polymarket.com/

GitHub:

GitHub logo Benjam1nCup / Polymarket-trading-bot-python-V2

polymarket trading bot polymarket bot polymarket twap bot polymarket arbitrage bot polymarket trading bot polymarket bot polymarket twap bot polymarket arbitrage bot polymarket trading bot polymarket bot polymarket twap bot polymarket arbitrage bot polymarket trading bot polymarket bot polymarket twap bot polymarket arbitrage bot polymarket bot

Polymarket Trading Bot | Polymarket Arbitrage Bot | Polymarket TWAP Trading Bot

An open-source and Strong Strategy collection of Polymarket trading bot and Polymarket arbitrage bot and Polymarket TWAP trading bot in Python for high-performance automated trading on polymarket crypto 5min and 15min markets.

Polymarket-benjamincup-bot-dashboard

This repository is primarily intended for educational and research purposes. It includes strategy concepts, implementation approaches, and selected performance screenshots to help developers understand how different automated trading strategies can be designed and tested.

The repository does not provide a complete production-ready trading bot source code. Instead, it provides strategy descriptions and research materials that you can use as a foundation for developing your own system.

If you are interested in building a Polymarket Trading Bot, you can follow my tutorials and use the concepts in this repository to develop your own implementation.

For users who prefer a ready-to-deploy solution or require custom strategy development, commercial…


View on GitHub


The repository contains strategy concepts and research material for automated Polymarket trading systems and is primarily intended for educational and research purposes.

Telegram:
https://t.me/BenjaminCup

Top comments (0)