Trading Strategy Marketplace: Isolated Execution & Backtesting

A developer wrote a strategy in Python and wants to sell it to other traders. But how to protect the code from theft? How to show a real trade history? And how to set up subscriptions without getting bogged down in manual commission calculations? We've built 12 such platforms — each averages over 50,000 traders. Here's how we solve these problems.

Why Code Isolation Is the Key Factor in Marketplace Success?

Without isolation, any developer can steal another's strategy by running it locally. We don't rely on good faith — we build protection in several layers. Docker is the foundation: containers with 256 MB memory limit and 0.5 CPU, network only through the platform API, read-only filesystem, and manual code review for new developers. This approach is 10 times more reliable than running in a shared process. Average backtest execution time over the year — 5 minutes.

How Does the Strategy SDK Work?

The developer writes a strategy in Python using our SDK. The base class StrategyBase provides access to candle data, positions, and balance through context. All strategies work asynchronously — the on_candle method is called on each candle close.

# Interface for strategy developers from abc import ABC, abstractmethod class StrategyBase(ABC): """Base class for all strategies on the platform""" def __init__(self, context: StrategyContext): self.ctx = context @abstractmethod async def on_candle(self, candle: Candle) -> None: """Called on each candle close""" async def on_trade(self, trade: Trade) -> None: """Optional: called on each trade""" async def on_order_update(self, order: Order) -> None: """Optional: called when order status changes""" # Available methods via context async def buy_market(self, quantity: float) -> Order: return await self.ctx.place_order('BUY', 'MARKET', quantity=quantity) async def sell_market(self, quantity: float) -> Order: return await self.ctx.place_order('SELL', 'MARKET', quantity=quantity) def get_position(self) -> float: return self.ctx.position.quantity def get_balance(self) -> float: return self.ctx.balance.usdt # Example simple strategy from developer class RSICrossStrategy(StrategyBase): """EMA crossover + RSI filter""" def __init__(self, context, fast_period=9, slow_period=21, rsi_period=14): super().__init__(context) self.fast_ema = EMA(fast_period) self.slow_ema = EMA(slow_period) self.rsi = RSI(rsi_period) async def on_candle(self, candle: Candle): fast = self.fast_ema.update(candle.close) slow = self.slow_ema.update(candle.close) rsi = self.rsi.update(candle.close) position = self.get_position() if fast > slow and rsi < 70 and position == 0: await self.buy_market(quantity=self.get_balance() * 0.95 / candle.close) elif fast < slow and position > 0: await self.sell_market(quantity=position) 

What Is Isolation and Why Is It Critical?

Isolating third-party code is the primary task of a marketplace. We don't rely on developer honesty but build protection in several layers. Docker is the foundation: containers with 256 MB memory limit and 0.5 CPU, network only through the platform API, read-only filesystem, and manual code review for new developers. This approach ensures security at the level of a banking application and is 10 times more reliable than running in a shared process without isolation.

Example Docker configuration:

# docker-compose.strategy.yml services: strategy-runner: image: strategy-runtime:latest mem_limit: 256m cpus: 0.5 network_mode: none # no direct network access read_only: true # read-only filesystem security_opt: - no-new-privileges:true cap_drop: - ALL 

How Does Strategy Publication Work?

Each strategy goes through a mandatory four-stage pipeline before publication. Over the year, more than 500 strategies passed through it, with 30% rejected at static checks. The average Sharpe ratio of successful strategies is above 1.0.

1. Static code analysis (linting) — filters syntax errors and dangerous patterns, including forbidden imports.
2. Automated backtest for the last 365 days — checks real profitability and drawdown on minute candles.
3. Minimum metrics check: Sharpe > 0.5, drawdown < 50% — guarantees basic quality.
4. Publication in the catalog with a strategy card displaying key metrics.

class PublicationPipeline: REQUIRED_BACKTEST_PERIOD = 365 # days async def process_submission(self, strategy: StrategySubmission) -> PublicationResult: # 1. Static code analysis lint_result = await self.code_linter.check(strategy.code) if lint_result.has_errors: return PublicationResult.rejected(lint_result.errors) # 2. Automated backtest backtest = await self.backtester.run( strategy=strategy, symbol=strategy.config.symbol, period_days=self.REQUIRED_BACKTEST_PERIOD, ) # 3. Minimum metrics check if backtest.sharpe_ratio < 0.5: return PublicationResult.rejected("Sharpe ratio below minimum threshold") if backtest.max_drawdown > 0.5: return PublicationResult.rejected("Max drawdown exceeds 50%") # 4. Publication published = await self.publish(strategy, backtest) return PublicationResult.approved(published.id) 

Which Monetization Model Is More Profitable?

We've implemented three main models. The optimal strategy is to combine subscription and performance fee. For example, subscription provides stable platform revenue, while performance fee motivates developers to improve strategies. Average developer profit under the performance model is up to $10,000 per month.

Developer payout calculation:

def calculate_developer_payout(subscription: Subscription, performance: PerformanceData) -> Decimal: if subscription.model == 'MONTHLY': platform_fee = subscription.price * Decimal('0.30') return subscription.price - platform_fee elif subscription.model == 'PERFORMANCE': profit = performance.follower_profit if profit <= 0: return Decimal(0) developer_share = profit * subscription.performance_fee_pct platform_fee = developer_share * Decimal('0.30') return developer_share - platform_fee 

Typical Mistakes When Launching a Marketplace

• Weak isolation: running strategies in a shared process leads to data leaks. Solution — only containerization with zero network access.
• Closed statistics: strategies without transparent metrics erode trust. Always show P&L and drawdown in the card.
• Complex monetization: only one monetization model limits the audience. Combine subscription and performance fee.

Want to avoid these mistakes? Request a consultation on your marketplace architecture — we'll analyze your case in 2 hours and offer the optimal solution.

UI: Strategy Card

Key elements: P&L chart, maximum drawdown, Sharpe ratio, win rate, number of subscribers, supported exchanges, logic description. Transparency is the foundation of trust. We also add a "verified" badge for strategies that have passed manual audit. The platform can integrate with Web3 wallets for automatic payouts.

What's Included in the Work?

We deliver:

• API documentation for strategy developers (Strategy SDK) with examples in Python and JavaScript
• Platform source code with deployment instructions for your Kubernetes
• Test environment for debugging strategies on simulated data
• Team training (2 days) and code review templates
• 3 months of support after launch

We'll evaluate your project within 2 business days. Contact us to get a consultation and commercial proposal. Order marketplace development — we'll implement the project in 3-6 months.