Strategy Architecture

How Podium deterministic strategies are structured and executed. A strategy is a Python class that turns market data into target portfolio weights. The engine owns everything else — order generation, fill simulation, risk enforcement, and portfolio accounting.

Core Components

Strategy Class

Subclass of Strategy implementing universe() and signal() (and optionally initialize() and risk_limits()). See the Strategy API.

StrategyContext

Passed to every method. Exposes ctx.date, ctx.portfolio, ctx.data, ctx.config, ctx.security_master, ctx.ops (alpha operators), and ctx.run_skill_script().

Backtest Engine

Deterministic, delay-1 simulation: signal at today's close, fill at the next open. Handles portfolio simulation, metrics, and bundle materialization.

Guardrails

8 checks (position size, sector caps, drawdown, daily loss, and more) run on every set of target weights. See Risk Limits.

Sandbox Runtime

Strategy code runs in an isolated Azure Dynamic Session — never with access to platform secrets. See the Security Model.

Execution Lifecycle

python
# Each trading day, the engine calls your Strategy in order:

ctx = StrategyContext(date, portfolio, data, config, security_master, ...)

strategy.initialize(ctx)          # once, on the first tick
symbols = strategy.universe(ctx)  # daily — which names to consider
weights = strategy.signal(ctx)    # daily — target weights {symbol: weight}
limits  = strategy.risk_limits(ctx)  # guardrail thresholds

# Engine then: applies guardrails -> derives orders from weight deltas
#              -> fills at next open (delay-1) -> marks to close
#              -> records portfolio snapshot + governance events

Next