When the market moves sharply by 5%, simultaneous liquidation of hundreds of positions can overload the engine. Delays of 200 ms lead to slippage of 1–2% — the exchange loses millions from the Insurance Fund. We design an engine that processes liquidations in <50 ms, preventing cascading losses. Contact us to discuss your system's architecture.
Why Margin Trading Requires a Fast Engine — Building a Margin Trading System
During market volatility, dozens of positions can reach the liquidation price simultaneously. If the engine cannot handle the load, delays result in execution at worse prices — the exchange suffers losses covered by the Insurance Fund. In the worst case, Auto-Deleveraging kicks in, causing user dissatisfaction. Our engine processes liquidations twice as fast as typical implementations thanks to parallel execution and atomic position marking.
Which Margin Modes We Support
Isolated Margin — each position has its own collateral. Risk is limited to that position. Suitable for traders who want to control risk per trade.
Cross Margin — all positions share a common collateral pool. Profitable positions support losing ones. Liquidation occurs only when the account balance becomes negative. Requires more complex minimum margin calculation.
| Parameter | Isolated | Cross Margin |
|---|---|---|
| Risk | Limited to position | Distributed across all positions |
| Collateral management | Per position individually | Total balance |
| Liquidation | When position collateral drops | When equity negative |
| Recommended for | Beginners, risk management | Professionals, hedging |
How Liquidation Price Is Calculated
For a Long position in isolated margin, liquidation occurs when the loss reaches (initial margin - maintenance margin fee). Formula:
func CalculateLiquidationPrice(pos IsolatedPosition, config MarginConfig) Decimal { maintenanceMarginAmount := pos.EntryPrice.Mul(pos.Quantity).Mul(config.MaintenanceMarginRate) lossAtLiquidation := pos.InitialMargin.Sub(maintenanceMarginAmount) priceDropAllowed := lossAtLiquidation.Div(pos.Quantity) if pos.Side == Long { return pos.EntryPrice.Sub(priceDropAllowed) } else { return pos.EntryPrice.Add(priceDropAllowed) } } Example liquidation price calculation
Long BTC, entry $42,000, leverage 10x → maintenance margin = 0.5% → liquidation price ≈ $38,010.How the Liquidation Engine Works
The engine receives price updates from the mark price oracle and checks all open positions. When the liquidation price is crossed, the position is atomically marked, a market order to close is placed, and a liquidation fee (typically 0.5–1.5%) is charged. The remaining collateral (residual) is returned to the user, and the loss is covered by the Insurance Fund. Key metric — time from trigger to order placement: <50 ms.
type LiquidationEngine struct { /* ... */ } func (le *LiquidationEngine) checkLiquidations(update PriceUpdate) { positions := le.db.GetPositionsForLiquidation(update.Pair, update.Price) for _, pos := range positions { go le.liquidatePosition(pos, update.Price) } } Financial Mechanisms: Insurance Fund, Funding Rate, and ADL
Insurance Fund
The Insurance Fund is built from liquidation fees. If a liquidation executes at a worse price than the liquidation price (slippage), the loss is debited from this pool. It is a reserve that protects the exchange from cascading losses.
Funding Rate
Perpetual contracts (Funding rate) have no expiration date. The funding rate is a mechanism that rewards or penalizes long/short positions based on the deviation of mark price from index price. We implement funding rate calculation based on premium:
func CalculateRate(markPrice, indexPrice Decimal) Decimal { premium := markPrice.Sub(indexPrice).Div(indexPrice) interestRate := Decimal("0.0001") clampedDiff := Clamp(interestRate.Sub(premium), -0.0005, 0.0005) return premium.Add(clampedDiff) } Funding is applied every 8 hours. Long pays short if rate > 0, and vice versa.
Auto-Deleveraging
If the Insurance Fund is exhausted, Auto-Deleveraging kicks in: the most profitable positions are forcibly closed to compensate for the loss. This is a last resort, and we design the system so that ADL triggers as rarely as possible — through a sufficient Insurance Fund and fast liquidations.
Why Mark Price Matters More Than Last Price
Liquidations should be based on an aggregated price from multiple exchanges (mark price), not the last trade. Otherwise, an attacker could manipulate last price with a small trade to trigger liquidations. We use the median from three sources (Binance, OKX, Bybit) with Chainlink integration:
func GetMarkPrice(pair string) Decimal { prices := []Decimal{binancePrice, okxPrice, bybitPrice} sort.Slice(prices, func(i, j int) bool { return prices[i].LessThan(prices[j]) }) return prices[1] } What the Trader Interface Looks Like
The user sees real-time margin ratio, liquidation price, P&L, and can add/withdraw collateral. We use React + wagmi + RainbowKit for wallet integration. Example component:
function PositionCard({ position }) { const marginRatio = position.equity / position.maintenanceMargin * 100; const urgency = marginRatio < 110 ? 'critical' : marginRatio < 150 ? 'warning' : 'safe'; return ( <Card> <PnLDisplay pnl={position.unrealizedPnl} /> <div>Liquidation: ${position.liquidationPrice.toFixed(2)}</div> <MarginRatioBar ratio={marginRatio} urgency={urgency} /> <AddMarginButton position={position} /> </Card> ); } What's Included in Turnkey Development
- Architectural documentation (UML diagrams, data flow descriptions)
- Smart contract development (Solidity) for collateral accounting and liquidations (if on-chain required)
- Backend engines in Go: isolated/cross margin, liquidation, funding, insurance fund
- Integration with Chainlink oracles for mark price
- UI components in React/TypeScript with WebSocket subscriptions
- Load testing (up to 10,000 positions in parallel)
- Deployment to cloud (AWS/GCP) and monitoring (Grafana, Prometheus)
- Training your team and 3-month post-launch support
Estimated Timelines
| Component | Timeline |
|---|---|
| Isolated margin engine | 4–5 weeks |
| Liquidation engine | 3–4 weeks |
| Cross margin | 3–4 weeks |
| Perpetual funding rate | 2–3 weeks |
| Insurance fund + ADL | 2–3 weeks |
| Mark price oracle | 1–2 weeks |
| UI for margin trading | 4–6 weeks |
| Full system | 4–6 months |
Cost is calculated individually based on complexity and required stack. For an accurate estimate, contact us — we'll conduct a free audit of your project and propose a solution. Request a consultation — we'll help reduce losses from liquidations. We guarantee NDA and transparent pricing.