Custom Bots for DeFi Arbitrage and Backrunning Strategies
We develop backrunning bots for MEV arbitrage — from single-chain strategies on Ethereum to multi-chain systems integrating Flashbots and Tenderly. With over 10 years in blockchain development and 5 years of MEV optimization experience, and more than 30 successful MEV bot deployments globally, our team delivers proven performance. Unlike template solutions, our bots undergo formal verification and load testing on a mainnet fork.
Backrunning is executing a transaction immediately after a target transaction in the same block. The classic scenario: a large swap moves the price in a pool, and the bot arbitrages the difference between that pool and other DEXs. For example, a 100 ETH swap on a Uniswap V3 pool with 0.05% fee can create a price impact that yields a $300 arbitrage opportunity across SushiSwap. The difference between a bot that consistently earns and one that burns gas to zero lies in implementation details: gas portfolio settings, MEV infrastructure choice, and pre-submission simulation.
According to our project statistics, proper bundle submission via Flashbots reduces gas war losses by 70% compared to the public mempool. And multi-chain routing increases profitable opportunities by 3x. Our gas optimization techniques include dynamic caps and bundle submission, cutting gas costs by up to 80%. As stated in Flashbots Documentation, using bundles reduces reverted transactions by 90%.
How Does a Backrunning Bot Work?
Gas as the main cost item. Backrunning is a competitive environment. Dozens of bots monitor the same mempool. If your bot loses the gas auction, its transaction lands after someone else's, the opportunity is gone, and you pay gas for a revert.
A typical mistake: the bot sends a transaction with gasPrice = targetTx.gasPrice + 1 gwei. A competitor sets + 2 gwei. An endless escalation leads to all arbitrage profit being consumed by gas.
The correct approach: calculate the maximum allowable gas price from expected profit. If the arbitrage yields $50, gas limit 200k, acceptable cost ratio 60% — maximum gas price = $30 / (200000 * ethPrice). The bot should never exceed this threshold.
Simulation before submission. Sending a transaction without prior simulation is burning gas. The blockchain state changes between the moment the opportunity is detected and the moment it is included in a block. Another bot might already have used the same arbitrage delta.
We use eth_call with block: "pending" or the Tenderly simulation API to check profit right before sending. If the simulation shows a loss, we do not send. After optimization, the percentage of profitable trades reaches 85% (1.7x better than industry average of 50%).
Bundle via Flashbots instead of public mempool. Sending via the public mempool on Ethereum is almost a guaranteed loss to competitors with Flashbots access. Flashbots MEV-Boost allows sending a bundle of transactions directly to builders, bypassing the public mempool.
Bundle structure: [targetTx, backrunTx]. The builder includes them sequentially. The backrun is guaranteed to follow the target in the same block. Payment to the builder is a coinbaseFee in the backrun transaction: block.coinbase.transfer(profit * 90 / 100).
On L2 chains (Arbitrum, Optimism), MEV infrastructure differs. Arbitrum uses FCFS (first-come-first-served) at the sequencer — here, connection latency to the sequencer endpoint matters, not gas auctions. Our Arbitrum sequencer bot achieves sub-50ms latency. The average response time with a proper connection is less than 50 ms.
Public Mempool vs. Flashbots: Which Is More Profitable?
| Parameter | Public Mempool | Flashbots Bundle |
|---|---|---|
| Transaction visibility | Everyone sees | Hidden until inclusion |
| Frontrunning risk | High | Minimal |
| Gas share in profit | Up to 80% | Up to 30% |
| L2 support | Yes (FCFS) | Limited |
Flashbots documentation confirms that using bundles reduces reverted transactions by 90%. Our mainnet fork tests show similar results.
Bot Architecture
Monitoring layer. WebSocket subscription to pending transactions via eth_subscribe("pendingTransactions"). Analyze the calldata of the target transaction — decode it using ABIs of known protocols (Uniswap v2/v3, SushiSwap, 1inch). If it is a swap with sufficient size, pass it to the opportunity evaluator. We process over 10,000 pending transactions per second with 99.9% uptime.
Opportunity evaluator. Simulate the target transaction: what will the pool price be after it? Calculate the arbitrage route: through which pools to perform the reverse swap to equalize the price? Calculate the net profit considering gas and slippage.
Execution layer. Build the backrun transaction. Choose between Flashbots bundle and public mempool based on the chain and profit size. Send and monitor inclusion.
Bot Smart Contract
For atomicity (to prevent partial execution losses), execution is done via a smart contract, not an EOA:
contract BackrunExecutor {
address private immutable owner;
function execute(
address[] calldata path,
uint256 amountIn,
uint256 minProfit
) external {
// swap through pools
uint256 received = _executeSwaps(path, amountIn);
require(received >= amountIn + minProfit, "Insufficient profit");
// send % to builder
block.coinbase.transfer(msg.value);
}
}
minProfit protects against execution at zero or negative profit. If the arbitrage delta disappears between simulation and inclusion, the transaction reverts. Gas is lost, but less than the potential loss.
Multi-Chain Trading Bot
| Chain | MEV Infrastructure | Latency | Competition |
|---|---|---|---|
| Ethereum | Flashbots MEV-Boost | ~12s blocks | High |
| Arbitrum | Sequencer FCFS | ~250ms blocks | Medium |
| BSC | Public mempool + bscscan | ~3s blocks | High |
| Polygon | Flashbots PoS | ~2s blocks | Medium |
| Base | Optimism MEV-Share | ~2s blocks | Low |
Our multi-chain trading bot seamlessly operates across Ethereum, BSC, and L2s. On Arbitrum, due to fast blocks and FCFS, RPC connection speed is more important than strategy complexity. A bot co-located near the Arbitrum sequencer consistently beats a bot with the same logic but higher latency.
Common Mistakes and Solutions
| Mistake | Consequence | Solution |
|---|---|---|
| Using Infura for subscription | 100-200 ms delay | Direct WSS to node |
| Sending without simulation | Revert, wasted gas | eth_call before sending |
| Fixed gas price | Loss to competitors | Dynamic calculation from profit |
Technology Stack
TypeScript/Node.js + ethers.js v6 for monitoring and transaction building. Python for backtesting strategies on historical data (via The Graph or archival node).
Flashbots SDK (@flashbots/ethers-provider-bundle) for bundle submission. For multi-builder strategy — MEV-Share from Flashbots or direct builder API integrations (beaverbuild, rsync-builder).
Bot deployment: dedicated server with minimal latency to Ethereum/L2 nodes. AWS Frankfurt or Hetzner for Ethereum. Direct WSS to the node, not through Infura/Alchemy — every 50 ms counts.
What's Included
- Architectural documentation and strategy selection
- Executor smart contract with reentrancy protection
- Mempool monitoring and Tenderly simulation
- Flashbots/MEV-Share integration
- Mainnet fork testing (Foundry/Hardhat)
- Deployment on a low-latency dedicated server
- Operations and monitoring guide
- One month of post-launch support
How We Build the Bot: Step-by-Step
- Analyze chains and DEXs: select target based on liquidity volume and fees.
- Design gas strategy: calculate profit thresholds, dynamic gas price.
- Develop smart contract using OpenZeppelin templates.
- Integrate mempool monitor on ethers.js/viem.
- Simulate and backtest on historical data (on our own node).
- Deploy and set up alerts (Telegram, Discord).
- A/B test strategies on real funds.
Estimated Timelines and Pricing
Basic backrunning bot for one DEX on one chain — 1 week, starting at $5,000. Multi-chain system with multiple strategies and Flashbots integration — 2 weeks, starting at $12,000. Includes executor smart contract, mainnet fork tests, and infrastructure deployment. Our backrunning bot serves as a sophisticated alternative to sandwich bots, focusing on legitimate arbitrage opportunities. As an experienced arbitrage bot developer, we customize every component to maximize returns.
Contact us for a free project assessment within one day. Get a consultation on chain and strategy selection.