Strategy Development Guide

This comprehensive guide covers everything you need to know about developing trading strategies in Planar. From basic concepts to advanced patterns, you'll learn how to build robust, profitable trading systems.

Strategy Fundamentals - Core concepts and architecture
Creating Strategies - Interactive and manual setup
Loading Strategies - Runtime instantiation
Advanced Examples - Multi-timeframe, portfolio, and optimization strategies
Best Practices - Code organization and performance tips
Troubleshooting - Common issues and solutions

Prerequisites

Before diving into strategy development, ensure you have:

Completed the Getting Started Guide
Basic understanding of Data Management
Familiarity with Execution Modes

Optimization - Parameter tuning and backtesting
Plotting - Visualizing strategy performance
Customization - Extending strategy functionality

Strategy Fundamentals

Architecture Overview

Planar strategies are built around Julia's powerful dispatch system, enabling clean separation of concerns and easy customization. Each strategy is a Julia module that implements specific interface methods through the call! function dispatch pattern.

Core Components

Strategy Module: Contains your trading logic and configuration
Dispatch System: Uses call! methods to handle different strategy events
Asset Universe: Collection of tradeable assets managed by the strategy
Execution Modes: Sim (backtesting-mode)), Paper (simulated live), and Live trading
Margin Support: Full support for isolated and cross margin trading

Strategy Type Hierarchy

Where:

Mode: Execution mode (Sim, Paper, Live)
Name: Strategy module name as Symbol
Exchange: Exchange identifier
Margin: Margin mode (NoMargin, Isolated, Cross)
QuoteCurrency: Base currency symbol

Dispatch System

The strategy interface uses Julia's multiple dispatch through the call! function. This pattern allows you to define different behaviors for different contexts while maintaining clean, extensible code.

Key Dispatch Patterns

Type vs Instance Dispatch:

Methods dispatching on Type{<:Strategy} are called before strategy construction
Methods dispatching on strategy instances are called during runtime

Action-Based Dispatch:

Exchange-Specific Dispatch

You can customize behavior for specific exchanges:

Margin Trading Concepts

Planar provides comprehensive margin trading support with proper position management and risk controls.

Margin Modes

NoMargin: Spot trading only

Isolated Margin: Each position has independent margin

Cross Margin: Shared margin across all positions

Position Management

Risk Management Patterns

Creating a New Strategy

Interactive Strategy Generator

The simplest way to create a strategy is using the interactive generator, which prompts for all required configuration options:

# Activate Planar project
import Pkg
Pkg.activate("Planar")

try
    using Planar
    
    # Example of strategy generation (interactive in real usage)
    println("Strategy generation example:")
    println("Strategy name: MyNewStrategy")
    println("Available timeframes: 1m, 5m, 15m, 1h")
    
    # Note: Planar.generate_strategy() is interactive and requires user input
    # This example shows the expected output format
catch e
    @warn "Planar module not fully available: $e"
end
   1d

Select exchange by:
 > volume
   markets
   nokyc

 > binance
   bitforex
   okx
   xt
   coinbase

Quote currency:
   USDT
   USDC
 > BTC
   ETH
   DOGE

Margin mode:
 > NoMargin
   Isolated

Activate strategy project at /path/to/Planar.jl/user/strategies/MyNewStrategy? [y]/n: y

Add project dependencies (comma separated): Indicators
   Resolving package versions...
   [...]
  Activating project at `/path/to/Planar.jl/user/strategies/MyNewStrategy`

┌ Info: New Strategy
│   name = "MyNewStrategy"
│   [exchange](exchanges.md) = :binance
└   [timeframe](guides/../guides/data-management.md#timeframes) = "5m"
[ Info: Config file updated

Load strategy? [y]/n: 

julia> s = ans

Non-Interactive Strategy Creation

You can also create strategies programmatically without user interaction:

Loading a Strategy

Basic Strategy Loading

Strategies are instantiated by loading a Julia module at runtime:

The strategy name corresponds to the module name, which is imported from:

user/strategies/Example.jl (single file strategy)
user/strategies/Example/src/Example.jl (project-based strategy)

After module import, the strategy is instantiated by calling call!(::Type{S}, ::LoadStrategy, cfg).

Strategy Type Structure

Example Strategy Module

Dispatch Convention

Rule of Thumb: Methods called before strategy construction dispatch on the strategy type (Type{<:S}), while methods called during runtime dispatch on the strategy instance (S).

Type Definitions:

S: Complete strategy type with all parameters (const S = Strategy{name, exc, ...})
SC: Generic strategy type where exchange parameter is unspecified

Manual setup

If you want to create a strategy manually you can either:

Copy the user/strategies/Template.jl to a new file in the same directory and customize it.
Generate a new project in user/strategies and customize Template.jl to be your project entry file. The strategy Project.toml is used to store strategy config options. See other strategies examples for what the keys that are required.

For more advanced setups you can also use Planar as a library, and construct the strategy object directly from your own module:

using Planar
using MyDownStreamModule
s = Planar.Engine.Strategies.strategy(MyDownStreamModule)

Strategy Interface Details

Function Signature Convention

The call! function follows a consistent signature pattern:

Subject: Either strategy type (Type{<:Strategy}) or instance (Strategy)
Arguments: Function-specific parameters
Verb: Action type that determines the dispatch (e.g., ::LoadStrategy)
Keyword Arguments: Optional parameters

Strategy Lifecycle

Understanding the strategy lifecycle is crucial for proper implementation:

Module Loading: Strategy module is imported
Type Construction: Strategy type is created with parameters
Instance Creation: call!(Type{<:SC}, config, ::LoadStrategy) is called
Reset/Initialization: call!(s::SC, ::ResetStrategy) is called
Execution Loop: call!(s::SC, timestamp, context) is called repeatedly
Cleanup: call!(s::SC, ::StopStrategy) is called when stopping

Essential Strategy Methods

Required Methods

Optional Methods

Advanced Dispatch Patterns

Conditional Dispatch by Mode

Parameter-Based Dispatch

List of strategy call! functions

Misc.call! — Function

Places a limit order and synchronizes the cash balance.

call!(
    s::Strategy{Misc.Live, N, <:ExchangeID, NoMargin, C} where {N, C},
    ai,
    t::Type{<:OrderTypes.Order{<:OrderTypes.LimitOrderType{S}, <:AbstractAsset, <:ExchangeID, P} where {S<:OrderTypes.OrderSide, P<:Misc.PositionSide}};
    amount,
    price,
    waitfor,
    synced,
    skipchecks,
    kwargs...
)

This function initiates a limit order through the _live_limit_order function. Once the order is placed, it synchronizes the cash balance in the live strategy to reflect the transaction. It returns the trade information once the transaction is complete.