Without liquidity, an exchange is dead: wide spread, deep price impact, traders leaving to competitors. Consider a typical task: an exchange launches a BTC/USDT pair, but the spread is 50 bps at a volume of $1000. Traders move to Binance. Our solution is to deploy a bot with a dynamic spread of 10 bps and a depth of $50k. Result: spread reduces to 15 bps, volume grows 5x. We develop turnkey market making systems — from strategy to production. The team has 10+ projects in DeFi and CeFi. Developing an exchange liquidity system (market making) requires deep understanding of market microstructure and risk management.
Why dynamic spread is critical for liquidity?
Static spread does not adapt to volatility and events. The result is either a loss during high volatility or loss of competitiveness. We use dynamic spread that widens during high volatility and before important events (FED, halvings). This allows maintaining profitability and providing liquidity in any situation.
How market making solves the liquidity problem?
Dynamic spread vs static — developing a liquidity system
Static spread does not adapt to volatility and events. The result is either a loss during high volatility or loss of competitiveness. We use dynamic spread that widens during high volatility and before important events (FED, halvings).
Inventory risk management
Without inventory management, a market maker can accumulate a huge position and lose money during a market reversal. Our bot automatically calculates inventory skew and shifts quotes to return to a neutral position. If limits are exceeded, a forced market order is placed on an external exchange.
Execution risk when hedging
The delay between a client trade and a hedge on Binance (1-100 ms) creates slippage risk. We minimize it through low-latency API and server colocation.
How is the bot architecture structured?
Basic bot architecture
class MarketMaker:
def __init__(self, symbol: str, config: MMConfig):
self.symbol = symbol
self.spread_bps = config.spread_bps
self.order_size_base = config.order_size
self.num_layers = config.num_layers
self.layer_spacing_bps = config.layer_spacing
async def compute_quotes(self, mid_price: float) -> list[Quote]:
quotes = []
inventory_skew = self.calculate_inventory_skew()
for i in range(1, self.num_layers + 1):
bid_offset_bps = self.spread_bps * i + inventory_skew
ask_offset_bps = self.spread_bps * i - inventory_skew
bid_price = mid_price * (1 - bid_offset_bps / 10000)
ask_price = mid_price * (1 + ask_offset_bps / 10000)
size = self.order_size_base / i
quotes.append(Quote('buy', bid_price, size))
quotes.append(Quote('sell', ask_price, size))
return quotes
def calculate_inventory_skew(self) -> float:
target_inventory = 0
current_inventory = self.get_current_inventory()
inventory_deviation = current_inventory - target_inventory
skew = inventory_deviation * self.inventory_skew_factor
return max(-self.max_skew_bps, min(self.max_skew_bps, skew))Hedging
async def hedge_trade(self, trade: InternalTrade):
hedge_side = 'buy' if trade.side == 'sell' else 'sell'
await self.hedge_exchange.market_order(
symbol=self.symbol,
side=hedge_side,
quantity=trade.quantity
)Inventory management
The key metric is inventory skew. We track the position in real time and shift quotes to return to neutrality.
def get_inventory_metrics(self) -> dict:
current_pos = self.get_position_btc()
pos_value_usd = current_pos * self.get_mid_price()
return {
"position_btc": current_pos,
"position_usd": pos_value_usd,
"max_inventory_usd": self.config.max_inventory_usd,
"utilization": abs(pos_value_usd) / self.config.max_inventory_usd,
"pnl_unrealized": self.calculate_unrealized_pnl(current_pos)
}What is execution risk and how to minimize it?
Execution risk arises from the delay between a client trade and the hedge. The longer the delay, the higher the probability that the price on the external exchange will change. We reduce this risk through low-latency API and server colocation near the exchange. In critical cases, we use a fixed spread to cover possible slippage.
How is dynamic spread calculated?
The spread is calculated as the sum of carry cost, expected adverse selection, and margin. Adverse selection is the probability of trading against an informed trader. In crypto, it is higher during high volatility and before major events.
def calculate_dynamic_spread(self) -> float:
base_spread = self.config.base_spread_bps
volatility = self.get_realized_volatility_1h()
vol_multiplier = max(1.0, volatility / self.baseline_volatility)
event_factor = 1.5 if self.is_event_window() else 1.0
hedge_spread = self.get_hedge_exchange_spread()
hedge_factor = max(1.0, hedge_spread / self.baseline_hedge_spread)
return base_spread * vol_multiplier * event_factor * hedge_factorLiquidity provider program
An exchange can attract external market makers via fee rebate. Standard tiers:
| Tier | Maker volume/30d | Maker fee | Taker fee |
|---|---|---|---|
| Standard | < $1M | 0.10% | 0.15% |
| Market Maker 1 | $1M+ | -0.01% (rebate) | 0.10% |
| Market Maker 2 | $10M+ | -0.02% (rebate) | 0.08% |
| Market Maker 3 | $100M+ | -0.03% (rebate) | 0.06% |
Negative maker fee means the exchange pays the market maker for each executed order. This is standard practice.
Performance requirements
def check_mm_performance(self, mm_id: str, period_minutes: int = 60) -> MMScore:
quotes = self.db.get_mm_quotes(mm_id, period_minutes)
total_seconds = period_minutes * 60
active_seconds = sum(q.duration for q in quotes if q.has_both_sides)
uptime = active_seconds / total_seconds
avg_spread = statistics.mean(q.spread_bps for q in quotes)
avg_depth_usd = statistics.mean(q.total_depth_usd for q in quotes)
return MMScore(
uptime=uptime,
avg_spread_bps=avg_spread,
avg_depth_usd=avg_depth_usd
)
On-chain AMM liquidity
For DEX, liquidity is provided through LP positions. Comparison:
| Parameter | CEX Market Making | AMM LP |
|---|---|---|
| Price control | Full | Algorithmic |
| Impermanent loss | No (hedged) | Yes |
| Infrastructure requirements | Bot + API | Simple transaction |
| Risk management | Active | Passive |
| Profitability | Higher | Lower |
For serious volume, CEX market making is more efficient. AMM is suitable as backstop liquidity for long-tail tokens.
Work process
- Liquidity and competitor analysis
- Strategy design with risk consideration
- Bot development in Python/Solidity + Foundry
- Historical testing and simulation
- Production deployment and monitoring
Timeline: from 2 weeks to 2 months depending on complexity. Cost is calculated individually.
What is included in the work?
- Architecture and strategy documentation
- Bot source code with exchange integration
- Hedging and inventory management setup
- Testing and optimization
- Support and improvements during the warranty period
We guarantee quality: certified engineers, experience with over 10 successful projects. Contact us for a project evaluation. Order turnkey market making system development — get a consultation on your project.