Build Your First Strategy on Podium

Introduction

Podium's default path is a deterministic Strategy SDK: you author a Python Strategy class, the platform backtests it against historical data in an isolated cloud sandbox, and you deploy it to paper trading — no infrastructure code required. This guide walks through building a momentum strategy end to end. By the end you will have a strategy that ranks US equities by trailing momentum, backtested and deployed to paper trading.

A note on vocabulary: you may see older material reference an "AI trading agent" or a no-code builder. The supported, kickoff path is the deterministic Strategy SDK described here. Autonomous agent capabilities exist on the same platform but are gated behind a feature flag and a higher governance bar — not the starting point. The SDK documentation is the source of truth.

How a Strategy Is Structured

A strategy is a Python class that extends Strategy from podium_sdk and implements two required methods — universe and signal — plus an optional risk_limits:

• universe(ctx) — return the list of symbols the strategy is allowed to trade.
• signal(ctx) — return a {symbol: target_weight} dict. Positive weights are longs, negative are shorts. The platform takes care of turning target weights into orders.
• risk_limits() — declare hard limits (max position size, gross exposure, drawdown) the platform enforces and your strategy cannot override.

You get market data and operators through the ctx (StrategyContext) object: ctx.data.close(lookback=...), ctx.data.returns(lookback=...), and the formulaic-alpha operators in podium_sdk.alpha_ops (rank, correlation, decay_linear, zscore, …).

Step 1: Start From a Template

From the dashboard, choose Create Strategy → Templates and clone Momentum Ranking. It comes pre-filled with a working momentum strategy — the fastest way to a running backtest. You can also start from a blank strategy and paste the example below.

Step 2: Write the Strategy

Here is a complete momentum-ranking strategy that goes long the top names by trailing return, equal-weight:

from podium_sdk import Strategy, StrategyContext, RiskLimits

class MomentumRanking(Strategy):
    TOP_N = 20
    LOOKBACK_DAYS = 126  # ~6 months

    def universe(self, ctx: StrategyContext) -> list[str]:
        # Trade everything with enough price history
        returns = ctx.data.returns(lookback=self.LOOKBACK_DAYS + 5)
        return list(returns.columns)

    def signal(self, ctx: StrategyContext) -> dict[str, float]:
        # Rank by trailing cumulative return; long the top N, equal weight
        returns = ctx.data.returns(lookback=self.LOOKBACK_DAYS)
        cum_return = (1 + returns).prod() - 1
        top_n = cum_return.nlargest(self.TOP_N)
        weight = 1.0 / len(top_n)
        return {symbol: weight for symbol in top_n.index}

    def risk_limits(self) -> RiskLimits:
        return RiskLimits(max_position_pct=0.10, max_gross_exposure=1.0)

A few things to notice:

• Target weights, not orders. signal returns desired portfolio weights; the platform computes the trades to get there. You never call a submit-order function.
• Operators are first-class. For anything more than plain ranking, pull from podium_sdk.alpha_ops — e.g. from podium_sdk.alpha_ops import rank, zscore, decay_linear — and apply them to the DataFrames returned by ctx.data. These mirror the formulaic-alpha literature so signals stay reproducible.
• Risk is declarative. risk_limits() sets bounds the engine will enforce regardless of what signal returns.

Step 3: Run a Backtest

Click Run Backtest on the strategy detail page. The engine simulates delay-1 fills (signals generated on close, filled at the next open) and marks positions to market at close — the same mechanics the live paper-trading tick uses. It typically finishes in under two minutes.

Review:

• Equity curve — portfolio value over the backtest window
• Sharpe / Sortino — risk-adjusted return
• Max drawdown — worst peak-to-trough decline
• Trade log — every generated order with its fill price and the decision context

Iterate on the signal, re-run, and repeat until the performance profile is one you'd be comfortable deploying. See Backtesting for the full mechanics.

Step 4: The Guardrails

The platform enforces hard limits your strategy cannot override:

• Position sizing — no single name above max_position_pct
• Gross exposure — total long + short capped at max_gross_exposure
• Concentration — sector and single-name caps
• Kill switches — the engine pauses a strategy that breaches its drawdown limit

These protect both the strategy and the platform. See Risk Management for the full set.

Step 5: Deploy to Paper Trading

Once the backtest is convincing, click Deploy. The strategy is version-locked: a hash of its code, config, and any skill bundle is recorded, so the deployed behavior is exactly what you backtested. Change the draft and the platform blocks re-deploy until you backtest the new version.

Deployed strategies run on the daily strategy-ticks cadence — generating target weights after the close and simulating fills at the next open, exactly as in the backtest.

Step 6: Monitor

The strategy detail page shows the live equity curve, daily P&L, position breakdown, and a full governance trail — every version, every signal, every decision. That evidence trail is the point: a deterministic strategy you can audit end to end.

Next Steps

• SDK documentation — the full reference
• Getting started — account setup and the dashboard flow
• Quickstart — the five-minute template walkthrough

Bring the edge. The operating layer is handled.