Spent another night testing Polymarket ideas outside my usual crypto 5-minute markets.
5 directions, ~80 variants. Same rule as always: find the idea on one half of the data, test it on the half I never looked at.
None survived. Here's what died and why 👇
1/ Favourites vs longshots
5,364 closed markets (politics, sports, pop culture, tech, geopolitics, economy), hourly price history.
First half: buying favourites at 85–95¢ made +2 to +7¢ per share after fee + 1¢ spread.
Untouched half: −3 to −6¢. Sports alone: −15¢.
Longshots at 1–15¢ ARE overpriced — but not by enough to pay the spread.
2/ Trading before a 5m window opens
Idea: before the start it should be 50/50, so fade anything far from 50¢.
Wrong. The strike is an average of the last minute, so pre-open prices already carry information.
−1 to −9¢ per trade on every period.
3/ New coins (BNB, DOGE, HYPE, ZEC)
Spreads are wide → taking liquidity loses 3–15¢ per trade.
Quoting inside the spread? 1,800 trades in 2 days. Nothing to work with.
4/ Weather
"Highest temperature in <city> today" vs live airport reports (METAR).
On price history: +13 to +24¢ per share buying NO on buckets already below the observed high.
Then I checked the real order books: 1 of 177 dead buckets had an actual bid.
The history was stale last-trade prices. Not tradable.
5/ Up + Down < $1 in the same market
Impossible by construction — Polymarket runs one book for both sides.
My take:
→ calibration on Polymarket is good almost everywhere I look
→ the most dangerous backtest number is a price you could never have traded at
→ before believing a result, check the live order book
Backtests, not financial advice.
data: Polymarket price history + @PendulumFlow
My trading bot was slowing down its own orders. The culprit: its own market data.
Normal order: ~250 ms.
During my two real trade attempts: 920 ms and 1,110 ms. Signing alone went from 10 ms to 100 ms.
Why? Python runs one thread at a time per process. The websocket thread was parsing 1,000+ order book messages per second, and exactly when an opportunity shows up, the book is at its busiest. The order thread was waiting in line.
More CPU cores wouldn't help. Rewriting in Rust would save ~10 ms out of 250, because most of that time is the exchange (~170 ms) and the network (~65 ms).
What helped: move the order books into their own process, on the other core. It parses everything and sends the strategy only the top levels that changed, every ~5 ms.
Measured on the server, from exchange timestamp to "book updated in my bot":
- median: 36 ms → 28 ms
- p90: 168 ms → 59 ms
- worst: 638 ms → 118 ms
The busier the market, the bigger the difference. Which is exactly when it matters.
Good question, and fair point. Binance side is exchange time but at 1s bars, Polymarket side is when the book update was recorded by the data provider. So treat the 0.2s as directional, not precise. What held across every latency I tried is the shape: the edge is mostly gone within a fraction of a second.
I backtested 362 Polymarket trading strategies on the 5 and 15-minute crypto markets.
Zero survived.
Here's how I tested them, how I tried not to fool myself, full stats on the best one, and the 3 things I actually learned 🧵
@pekoz51 Ha, agreed. The hardest part was keeping a test set I wasn't allowed to look at. Most of the other 416 looked great right up until they hit it.
I've backtested 417 strategies on Polymarket's 5 and 15-min crypto markets.
One finally survived every test.
I'm not sharing the exact rules (sorry), but here's what I can say:
- it's not a prediction or an indicator. It comes from how these markets decide the winner, a detail in the resolution rules most people skim past. I skimmed past it too, a week ago.
- it doesn't need speed. Still works with a 5-second delay.
- it's tiny. About 3 chances a day across BTC, ETH, SOL and XRP.
Stats across Oct 1-11 and Oct 28-Nov 8 (incl. the week I never looked at):
- 73 trades, 73 winners
- avg entry 97c, +8.7% per trade
- fees paid: $15
- max drawdown: $0
- green days: 22 of 22
Caveats: small sample, top of book only, depth not modelled. Next step is checking it on more history.
The lesson I can share: the edge wasn't in a clever indicator. It was in reading the rules. Twice.
(backtest only, not financial advice. data: @PendulumFlow)
@tomaxyn Tempting, but reversing doesn't flip the sign. Selling the 1-2c side means risking ~98c to make 1-2c, and one hit wipes out 50+ wins. The bias is real but small, and fees eat most of it.
"Just use limit orders, you'll save on fees."
I tested it. Resting bids 3c under the favourite in the last 2 minutes of 5 and 15-min crypto markets (only when the favourite is priced 85c+).
No taker fees. Filled only when a real trade went through my price.
- 818 fills
- avg entry 89.6c
- win rate 80.8%
- fees paid: $0
- result: -$804 (-9.8% per trade)
- max drawdown: $855, green days 0/4
Read those two numbers again: I bought at 89.6c and won only 80.8% of the time.
That's adverse selection. Your bid gets filled exactly when someone knows the favourite is in trouble. When it's going to win, price never comes down to you.
A fill is information, and it's bad information.
(backtest only. data: @PendulumFlow)
I bought 2,742 lottery tickets on Polymarket.
The rule: in the last minute of a 5 or 15-min crypto market, buy the losing side if it costs 3c or less. If it hits, you get 30-100x.
6 days, BTC/ETH/SOL/XRP:
- avg ticket price: 1.3c
- hit rate: 0.5% (priced like 1.3%)
- fees paid: $1,895 (fees on cheap shares are ~7% of your stake!)
- best ticket: +$925
- result: -$20,091 on $27,420 staked (-73%)
- longest losing streak: 665 in a row
The peak was +$1,113 after just 29 tickets. That's how it gets you: one early hit and you think you've found something.
Cheap outcomes on Polymarket aren't underpriced. If anything, they're overpriced.
(backtest only. data: @PendulumFlow)
@BarwiseAPI Haven't split it by duration yet, good idea, I'll check. And yes, the +$1.1k peak after 29 tickets is the most dangerous part of the whole chart. That's exactly when you'd scale up.
@polytutor Yeah, logging it was the eye-opener. Only 1 of 29 live trades filled both legs cleanly, and the leg that misses is usually the one price just ran away from, so the leftover leg is the wrong one to hold. Ended up switching that bot off. Happy to swap notes here in the replies.
I took a backtested Polymarket strategy live with $10 trades. Here's what broke in the first 24 hours.
None of it showed up in the backtest.
1. The exchange rejected my best entries.
Five orders in a row: "invalid amounts". Polymarket wants shares × price in whole cents. My bot sized 10.3 shares at 15c = $1.545. Rejected. Those were the best prices of the night.
Fix: whole shares. And near 0 or 1 the tick drops to 0.1c, so there it has to be multiples of 10.
2. One leg filled, the other didn't.
The trade has two legs that only make sense together. Both orders go out in one request, but the exchange fills them independently. One filled. The other side had exactly 10 shares and someone got there first.
Fix: never take more than 60% of the visible depth, then a 5-second repair window that watches the book and completes the pair at a small known cost, or sells the extra leg back with a capped loss.
3. My "sell it back" didn't sell.
I tried to sell 10.526316 shares. Same rounding rule, other direction. The position stayed open. It happened to win. That's luck, not risk management.
4. My price feed went quiet without disconnecting.
Socket open, no data. The bot silently fell back to a worse source in half the windows.
Fix: a watchdog. 15 seconds of silence = reconnect.
Backtests tell you if an idea can work. The first week live tells you if your code can.
@jonbushquant The 17h one is scary. I had the same blind spot: my daily loss cap read PnL from the API, so a restart during an outage would've reset it to zero. Moved it to a local journal that survives restarts. Do you reconcile positions on-chain now or still trust the API?
Idea I tested today: Polymarket's 5 and 15-min crypto markets take ~2.5 minutes to resolve after the window ends.
The winner is already decided at that point. So can you buy it at 97-98c and collect $1?
No. The market stops taking orders the second the window closes.
12 days, BTC/ETH/SOL/XRP, every window:
- median time from window end to resolution: 141 s
- winner-side trades in that gap: 30
- volume traded below 99c: $183. Total.
Some edges are fast. Some don't exist. This one is the second kind.
Your Polymarket bot is probably slower than you think. I measured mine.
From a server with a 5 ms ping to Polymarket:
- signing an order locally: 9 ms
- round trip to the CLOB API: ~65 ms (the 5 ms is just the Cloudflare edge)
- posting a FOK order and getting the answer: ~235 ms
So ~170 ms of every order is Polymarket itself. No VPS fixes that.
But the real surprise was in the official Python client.
After an order matches, py-clob-client-v2 doesn't return right away. It polls the trade until the on-chain settlement hash shows up. Up to 30 seconds.
The order was filled in milliseconds. My code was waiting for the blockchain. That's where my random 1.5 s "slow orders" came from.
Other things that were quietly adding latency:
- a balance request before every order
- tick size / neg-risk lookups on the first order in each new market (on 5-min markets that's every 5 minutes)
- a sleep between retries
And on the data side: 8 order books on these markets push well over 1,000 websocket messages per second. Parse them on the same thread that reads the socket and Polymarket disconnects you ("slow consumer"). Queue the raw frames, parse elsewhere.
None of this is a strategy. It's plumbing. But plumbing decides whether your backtest survives contact with the live market.
Same strategy. Same 419 signals. Same week of BTC data.
Instant reaction: +$1,638 (+39% per trade)
0.5 second reaction: -$1,101 (-26.5% per trade)
The strategy: Binance moves 3+ bps in 8 seconds, Polymarket's price hasn't moved yet, buy the direction Binance went.
What changes between the two runs?
Win rate: 32.2% vs 31.6%. Basically the same.
Average entry price: 28.7c vs 31.0c.
That's it. In half a second the market reprices by ~2 cents, and those 2 cents ARE the edge. Win 32% of the time while paying 28.7c = profit. Win 32% while paying 31c = slow bleed after fees.
Full stats, instant vs 0.5s:
- trades: 419 vs 415
- fees paid: $209 vs $200
- peak P&L: +$2,008 vs +$26
- max drawdown: $751 vs $1,507
- profit factor: 1.58 vs 0.61
- green days: 7/11 vs 4/11
Honest note: the instant run includes one 1c ticket that paid $925. Without it, still +$713.
My take: "instant" isn't achievable from a home setup. The bots that win this game sit next to the exchange. If your strategy only works with zero delay, you don't have a strategy, you have a latency race.
(backtest only. data: @PendulumFlow)
Round 2 of backtesting Polymarket's 5 and 15-min crypto markets. This time I went for the weird ideas:
- only trade windows that close on the full hour
- after a big upset (85c+ favourite loses), bet on the next window
- follow or fade the 1h / 4h / 12h trend
- BTC crosses a round $1000 level mid-window
- ETH/SOL/XRP vs BTC relative moves
- all 4 coins closed the same way last window
- "Up wins ties", so maybe Up is underpriced?
- late favourites, but only in quiet low-volume windows
8 ideas, 54 variants. Survivors: 0.
Running total: 416 tested, 0 survived.
My favourite failure, with full stats:
When BTC, ETH, SOL and XRP all close the same way, the next window seemed to reverse a bit more often. So I bet against the streak on a week I never looked at:
- 5,212 trades, $10 each
- win rate 47.5%, avg entry 48c
- fees paid: $1,905
- peak: +$649
- final: -$1,970 (-3.8% per trade)
- max drawdown: $2,651
- profit factor 0.93, worst losing streak 42
Then I checked betting WITH the streak on the same week: 5,051 trades, -$1,845, -3.7% per trade.
My take: both sides of the same bet lose the same amount, and the loss is almost exactly the fees. Win rate = entry price. There's no pattern here, just the house edge, collected 5,000 times.
Same rules as always: tuned on one period, scored once on a different week, taker fees + 0.5s delay, real orderbook data from @PendulumFlow, official outcomes.
Next: slower markets where being a bot isn't the whole game. Got an idea for me to test? Reply and I'll run it.
(backtest only, not financial advice)
Next round: weirder ideas that don't depend on being fast. Time-of-day effects, cross-coin stuff, hourly and daily markets.
Got a strategy you want me to backtest? Drop it below and I'll run it through the exact same test, including the week I don't look at.
(backtest only, not financial advice)
The best candidate up close: "spike hold"
Idea: Binance prints a big 1-second candle (8+ bps), buy that direction on Polymarket and hold to the end.
On the week I never looked at:
- 558 trades, $10 each
- win rate 62.4%, avg entry 62c
- fees paid: $148
- peak: +$242 after 126 trades
- final: -$213 (-3.8% per trade)
- max drawdown: $517
- profit factor 0.9, worst losing streak 8
- green days: 2 of 6
My take: a 62% win rate sounds great until you see the average entry is 62c. You win exactly as often as you pay for, then fees eat you.
And that early peak? One 6c ticket that paid $146. Without it the peak is under $100.