I’ve spent countless hours reading about trading strategies that promise massive, life-changing returns. Almost all of them rely on the same impossible premise: predicting exactly where the market is going next.
Predictive trading doesn’t interest me.
What fascinates me is something much smaller, quieter, and highly technical: one basis point.
A single basis point (BPS) is just 0.01%. To most retail traders, it’s invisible noise—barely worth a second thought. But when you are running high-frequency, automated trading strategies, those tiny fractions of a percent dictate whether you survive or get wiped out.
This blog is an engineering diary documenting my journey of building a crypto funding rate arbitrage system from scratch.
I’m not launching this because I have all the answers. In fact, I expect to break things, lose money on bad assumptions, and completely rewrite my codebase multiple times. I would rather document the messy, frustrating reality of quantitative trading than pretend everything works perfectly on the first deploy.
The Core Philosophy: Aggregation of Marginal Gains
The thesis behind this project is simple: relentless optimization.
- Execution: If I can optimize my order entry and execution to save a single basis point, that’s a win.
- Fee Structure: If I can optimize fee tiers, utilize market-maker rebates, or route orders smarter to shave off half a BPS, that’s another win.
- Capital Efficiency: If I can find a safer way to utilize margin or automate collateral rebalancing between exchanges, it compounds the returns.
On their own, none of these micro-optimizations look impressive. They won’t make a flashy social media post. But when you layer them on top of one another, they completely transform the math of a trading system.
What if capturing a single extra basis point, consistently and compounded over a long horizon, is the boundary line between a hobbyist script and a highly profitable institutional-grade fund?
That is what I am building this system to find out.
┌──────────────────────────────┐
│ Funding Rate Arbitrage Bot │
└──────────────┬───────────────┘
│
┌───────────────────────┼───────────────────────┐
▼ ▼ ▼
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ Fee Reduction │ │ Execution Speed │ │ Capital Routing │
│ -0.005% fee │ │ Slippage BPS │ │ Margin Yield │
└─────────────────┘ └─────────────────┘ └─────────────────┘
Why 1 BPS Matters: The Compounding Math
Let’s look at why micro-optimizations matter in high-frequency arbitrage.
In funding rate arbitrage, you are collecting yield multiple times a day (often every hour depending on the perpetual swap contract). When you compound yields at that frequency, the mathematical difference between 1 basis point and 2 basis points over a year is staggering.
If we start with an initial capital of 5,000 USDT and capture these yields hourly over 365 days (8,760 compounding periods):
| Hourly Yield |
Ending Balance |
Net Profit |
Annual Return |
| 1 BPS (0.01%) |
≈ 12,005 USDT |
≈ 7,005 USDT |
≈ 140.1% |
| 2 BPS (0.02%) |
≈ 28,824 USDT |
≈ 23,824 USDT |
≈ 476.5% |
A difference of just 0.01% per hour more than doubles your final portfolio value by the end of the year.
This is why I refuse to ignore the details. Lowering exchange fees, minimizing slippage, deploying faster infrastructure, and building smarter capital allocation tools aren’t just minor technical chores—they are the strategy itself.
What to Expect on This Blog
This won’t be a blog filled with “get rich quick” screenshots or vague trading signals. Instead, think of this as an open-source engineering log.
As I build basisrush.fund, I’ll be sharing concrete data, technical bottlenecks, and raw performance metrics. Here is exactly what I will be documenting:
- Statistical Arbitrage Research: Quantitative ideas, backtesting models, and mathematical assumptions.
- Raw Funding Rate Data: Historical analysis across major derivative exchanges like Binance, Bybit, and OKX.
- Infrastructure & Automation: My server setup, latency reduction strategies, and automated risk management.
- Exchange API Quirks: Documenting the undocumented rate limits, websocket dropouts, and API bugs I encounter.
- Real Performance Metrics: Transparent tracking of my capital, fees, slippage, and net PnL.
I am building this system in public, one basis point at a time. If you’re interested in algorithmic trading, DeFi infrastructure, or quantitative finance, subscribe to follow along.
Let’s build.
