Copy Trading System Development
Copy trading is automatic copying of experienced trader (leader) trades on subscriber (follower) account. For exchange this is powerful retention and monetization tool: followers retained, leaders attract audience, exchange gets additional trading volume. Technically non-trivial: need proportional copying, risk management for followers, minimal latency between signal and execution.
System Architecture
Key Components
Leader Trading Account
│ trade events
▼
Signal Processor ──── Position Normalizer
│
▼
Distribution Engine ──── Risk Filter
│
├──► Follower 1 Order ──► Exchange OMS
├──► Follower 2 Order ──► Exchange OMS
└──► Follower N Order ──► Exchange OMS
Signal Processor — intercepts leader trading events in real time.
Position Normalizer — converts leader action to abstract signal: "open long BTC at 5% of portfolio with 2x leverage".
Distribution Engine — broadcasts signals to all followers. For thousands of subscribers — high-load fanout.
Risk Filter — checks if signal can be executed for specific follower considering balance, limits, risk settings.
Copy Modes
| Mode | Description | For |
|---|---|---|
| Fixed amount | Copy each leader trade at fixed amount ($100) | Conservative |
| Proportional | Copy proportional to balance (leader opens 10% → follower too) | Balanced |
| Multiplier | Proportional × coefficient (0.5x – 2x of leader size) | Flexible |
| Fixed ratio | Fixed leverage ratio | Advanced |
Proportional mode is industry standard:
def calculate_follower_order_size(
leader_trade: Trade,
follower: FollowerSettings,
leader_portfolio_value: float
) -> float:
leader_position_percent = leader_trade.notional_value / leader_portfolio_value
if follower.copy_mode == 'proportional':
raw_size = follower.allocated_amount * leader_position_percent * follower.multiplier
else:
raw_size = follower.fixed_amount_per_trade
# Risk limits
max_allowed = follower.allocated_amount * (follower.max_position_percent / 100)
raw_size = min(raw_size, max_allowed)
# Exchange minimum order
min_order = get_min_order_size(leader_trade.symbol)
if raw_size < min_order:
return 0 # don't copy too small
return raw_size
Latency and Execution
Why Latency is Critical
Copy trading is execution race. If leader opened position and followers get order through 500ms — price already shifted. Especially critical on volatile markets.
Optimizations:
Event bus instead of polling: leader signal → Kafka topic → consumer group for each follower segment. Distribution latency: <10ms for 10,000 subscribers.
Pre-allocated order capacity: for top leaders with thousands of followers — reserve capacity in matching engine.
Order batching: aggregate follower orders into single batch, then distribute fills. Reduces matching engine load.
Slippage Management
With many copiers total order volume can move market, worsening execution for all:
- TWAP execution: split large aggregated order into parts by time
- VWAP execution: execute by VWAP algorithm for minimal impact
- Slippage cap: if slippage exceeds N% — order not executed, follower notified
Leader Ranking
Performance Metrics
Public leader ranking is product showcase. Metrics must be manipulation-resistant:
class LeaderPerformanceMetrics:
def calculate(self, leader_id: str, period_days: int = 30) -> dict:
trades = self.db.get_closed_trades(leader_id, days=period_days)
if not trades:
return {"insufficient_data": True}
# Basic metrics
total_pnl = sum(t.pnl for t in trades)
total_pnl_percent = (total_pnl / self.get_start_capital(leader_id)) * 100
# Win rate
wins = [t for t in trades if t.pnl > 0]
win_rate = len(wins) / len(trades)
# Profit factor
gross_profit = sum(t.pnl for t in wins)
gross_loss = abs(sum(t.pnl for t in trades if t.pnl < 0))
profit_factor = gross_profit / gross_loss if gross_loss > 0 else float('inf')
# Max drawdown
equity_curve = self.build_equity_curve(trades)
max_drawdown = self.calculate_max_drawdown(equity_curve)
# Sharpe Ratio
daily_returns = self.calculate_daily_returns(equity_curve)
sharpe = self.sharpe_ratio(daily_returns)
# Calmar Ratio
calmar = total_pnl_percent / abs(max_drawdown) if max_drawdown != 0 else 0
return {
"roi": total_pnl_percent,
"win_rate": win_rate,
"profit_factor": profit_factor,
"max_drawdown": max_drawdown,
"sharpe_ratio": sharpe,
"calmar_ratio": calmar,
"total_trades": len(trades),
"avg_trade_duration_hours": self.avg_duration(trades)
}
Metric Gaming Protection
Leaders can try to manipulate metrics. Solutions:
Problem: open many small profitable trades → high win rate. Hold one big loss open → doesn't reflect in closed PnL.
Solution: include unrealized PnL in calculations. Positions open >N days counted by mark price.
Problem: trade demo account first 30 days, then switch to live with nice history.
Solution: require minimum real volume to get leader status. Verify executed order compliance.
Risk Management for Followers
Protective Settings
@dataclass
class FollowerRiskSettings:
# Max loss per trade
max_loss_per_trade_percent: float = 2.0
# Max daily loss (stop copying if hit)
daily_loss_limit_percent: float = 5.0
# Max lifetime loss (pause copying)
total_loss_limit_percent: float = 20.0
# Max position in % of allocated
max_position_size_percent: float = 30.0
# Allowed instruments
allowed_symbols: list = field(default_factory=list)
# Max leverage for copying
max_leverage: int = 10
# Stop copying on leader drawdown
stop_if_leader_drawdown_percent: float = 15.0
On limit breach — system automatically stops copying and notifies user.
Monetization
Fee Models
Performance fee (profit sharing): leader gets % of follower's profit. Standard: 5-30%. Paid monthly or on position close.
Management fee: fixed monthly subscription. Regardless of result.
Hybrid: small management fee + performance fee.
Platform fee: exchange takes share of leader's performance fee.
High Water Mark
def calculate_performance_fee(follower_id, leader_id, fee_rate = 0.15) -> float:
account = self.db.get_copy_account(follower_id, leader_id)
current_value = account.current_value
hwm = account.high_water_mark # historical maximum
if current_value <= hwm:
return 0.0 # no new profit — no fee
new_profit = current_value - hwm
fee = new_profit * fee_rate
# Update HWM
self.db.update_hwm(follower_id, leader_id, current_value)
return fee
High Water Mark mandatory for fair system. Without it: leader loses 30%, recovers 30% — follower pays commission twice.
Regulatory and Compliance
In some jurisdictions copy trading qualifies as investment advice or portfolio management, requiring leader licensing. Consult lawyers for target markets. Minimum precautions: "past performance doesn't guarantee future results" disclaimers, limits on max amounts for unverified users.
Technically copy trading is event-driven architecture with strict latency requirements and reliability. Losing one signal means open position at leader without corresponding at follower — unhedged risk exposure.