Read time … min

GitHub-Native Trading Strategy Deployments

Connect GitHub, choose your own repo or create one from a TradingHost template, and deploy trading strategies into always-on cloud runtimes.

TradingHost uses GitHub as the source of truth for your trading code. Sign up with GitHub, connect an existing repository or create a new one from an open-source or TradingHost template, then launch a deployment that runs your selected strategy in a TradingHost runtime.

GitHub-native lifecycle

  • GitHub sign-up
  • Existing repo support
  • One-click repo creation
  • Strategy-level deployments
  • Start and stop controls
  • Automatic redeploys from main
  • No state lock-in

Section 01 · Concept

What is a TradingHost deployment?

A deployment is a running instance of a trading strategy on TradingHost.

Your GitHub repository contains the code. TradingHost reads that code, prepares the runtime, injects your configured secrets, and starts the selected strategy inside a containerised environment.

A single repository can contain one strategy or multiple strategies. When you create a deployment, you choose which strategy TradingHost should run, where it should run, and what runtime configuration it should use.

Repo
equals source code.
Strategy
equals the trading logic you choose to run.
Deployment
equals the live runtime instance running that strategy.

Section 02 · Onboarding

Sign up and deploy with GitHub

TradingHost starts with GitHub because serious trading code needs version control, reviewable changes, and a clean source of truth.

When you register with TradingHost, you authenticate with GitHub. From there, you can connect your own repository or create a new repository from a supported template.

  1. STEP 01

    Sign up with GitHub

    Use your GitHub account to create a TradingHost account and authorise the required repo permissions.

  2. STEP 02

    Choose your repository path

    Connect an existing repository, create a repo from an open-source framework template, or create a blank TradingHost project.

  3. STEP 03

    Configure the deployment

    Choose the strategy, runtime region, secrets, resource profile and deployment settings.

  4. STEP 04

    Launch

    TradingHost starts the strategy in a managed runtime and streams logs back to your dashboard.

Section 03 · Repo paths

Bring your own repo or create one from a template

TradingHost supports three ways to start a deployment.

  • Bring your own repository

    Already have a trading project in GitHub? Connect the repo to TradingHost, choose the strategy entry point, add secrets, select a region, and deploy.

  • Create from an open-source framework template

    Use a deployment-ready project structure for supported open-source frameworks such as CCXT or Freqtrade. TradingHost creates the repository in your GitHub account, then you customise the code and deploy it.

  • Create a blank TradingHost template

    Start with a clean TradingHost-ready project structure. This is useful if you want to build your own Python strategy from scratch while keeping the runtime configuration, folder structure and deployment entry point clear.

Templates are project scaffolds, not profitable strategies. They provide structure, configuration examples and runtime compatibility. You bring the trading logic, risk controls and broker or exchange configuration.

Section 04 · Template ownership

When you choose a template, the repo is yours

If you choose an open-source framework template or a TradingHost blank template, TradingHost creates a new repository inside your GitHub account.

That repository belongs to you. You can edit it, branch it, commit to it, review it, and manage it like any other GitHub project. TradingHost uses the repository as the deployment source, but your code remains in your GitHub account.

A template includes

  • Project structure
  • Runtime configuration
  • Example environment variable names
  • A strategy entry point
  • Logging examples
  • Dependency files
  • TradingHost deployment configuration
  • Basic README instructions

Templates are project scaffolds, not profitable strategies. They provide structure, configuration examples and runtime compatibility. You bring the trading logic, risk controls and broker or exchange configuration.

Section 05 · Strategy controls

Deploy the strategy you want to run

A repository can contain more than one strategy, script or runtime entry point. TradingHost treats the deployment as the live runtime instance, not just the repository itself.

When you launch a deployment, you choose the strategy or entry point you want TradingHost to run. You can then start, stop, restart or update that deployment from the TradingHost dashboard.

  • Start the strategy

  • Stop the strategy

  • Restart the runtime

  • View logs

  • Update secrets

  • Change runtime configuration

  • Redeploy the latest code

  • Review deployment status

The repo
is your codebase.
The deployment
is the running strategy.
The dashboard
is your control surface.

Section 06 · Auto-redeploy

Push to main, redeploy in seconds

TradingHost is designed for fast iteration. When you update the main branch of the connected repository, TradingHost can pull the latest changes and redeploy the associated deployment automatically.

This lets you keep your development workflow centred around GitHub. Make a change, push to main, and the running deployment receives the latest version without manually rebuilding your environment.

  1. Edit your strategy locally or in your AI development environment
  2. Commit and push changes to the main branch
  3. TradingHost detects the update
  4. The deployment pulls the latest code
  5. The runtime restarts with the new version
  6. Logs show the updated runtime behaviour

Section 07 · State ownership

TradingHost redeploys code. You own strategy state.

TradingHost does not hold your strategy state for you.

When a deployment redeploys, restarts or moves to a new runtime, your code should be designed to recover safely. Any strategy state, position tracking, open order awareness, database persistence, checkpointing or reconciliation logic is your responsibility unless explicitly provided by your own application or external services.

Examples of state

  • Open position assumptions
  • Last processed candle/trade
  • Order IDs
  • Grid levels
  • Trailing stop values
  • Risk counters

Guidance

For live trading, your strategy should be able to rebuild its view of the world from broker or exchange APIs, stored external data, or your own persistence layer. Do not rely on in-memory state surviving a redeploy, restart or crash.

Clear boundary

TradingHost provides deployment, runtime and observability controls. It does not guarantee continuity of user-created in-memory strategy state.

Section 08 · AI-assisted

Built for AI-assisted development

TradingHost deployments are designed to work with AI-assisted coding workflows. You can build and edit strategies in tools such as Cursor or Claude Code, push changes to GitHub, and let TradingHost redeploy the latest version.

With MCP support, compatible tools can also interact with TradingHost functions such as listing deployments, inspecting logs and triggering redeployments.

Reply to Claude…
Explore MCP for TradingHost

Section 09 · Lifecycle

The deployment lifecycle

Every deployment follows a simple lifecycle from repository to running strategy.

  • Created

    The deployment is configured but not yet running.

  • Starting

    TradingHost is preparing the runtime and starting the strategy process.

  • Running

    The strategy is active inside the selected runtime.

  • Stopped

    The deployment is intentionally stopped and no strategy process is running.

  • Restarting

    TradingHost is restarting the runtime or strategy process.

  • Redeploying

    TradingHost is pulling the latest code and starting the deployment again.

  • Failed

    The runtime or strategy process failed to start or continue running. Logs should be reviewed.

Deployment states help you understand what TradingHost is doing and where to look next. If a deployment fails, logs are the first place to inspect.

Section 10 · Responsibility split

Where TradingHost ends and you begin

TradingHost manages the deployment layer around your trading code. You remain responsible for the trading system itself.

TradingHost manages

The deployment layer

  • GitHub connection
  • Repo selection or repo creation
  • Deployment configuration
  • Runtime startup
  • Secret injection
  • Region selection
  • Basic health state
  • Raw log streaming
  • Start and stop controls
  • Redeploy workflow

You are responsible for

The trading system

  • Strategy logic
  • Broker and exchange permissions
  • API key creation
  • Risk controls
  • Position reconciliation
  • Order handling
  • Error handling
  • External persistence
  • Testing before live trading
  • Monitoring live behaviour
  • Compliance with broker or exchange terms

Direct statement

TradingHost makes it easier to deploy and operate trading code. It does not make trading code safe, profitable or correct by default.

Section 11 · Repo patterns

Supported repository patterns

TradingHost is designed to support different repository shapes as long as the deployment entry point and runtime configuration are clear.

  • Single strategy repo

    One repository contains one strategy and one deployment entry point.

  • Multi-strategy repo

    One repository contains multiple strategies. Each TradingHost deployment selects the strategy it should run.

  • Framework project

    One repository contains a supported framework project such as CCXT or Freqtrade.

  • Blank project

    One repository starts from a TradingHost-ready blank structure and grows into your own strategy codebase.

For predictable deployments, keep entry points, environment variables and runtime configuration explicit.

Related

Where to go next

FAQ

Frequently asked questions

Yes. TradingHost v1 uses GitHub as the source of truth for strategy code and deployment updates.

Yes. You can connect an existing GitHub repository and deploy a strategy from it.

Yes. If you choose an open-source framework template or a TradingHost blank template, TradingHost can create a new repository in your GitHub account.

No. Templates are deployment-ready project structures. They may include example code, configuration and entry points, but they are not profitable strategies, trading signals or financial advice.

When automatic redeploys are enabled, TradingHost can pull the latest changes from the main branch and redeploy the associated runtime in seconds.

No. TradingHost does not hold user strategy state. Your code should manage persistence, broker reconciliation and recovery logic if your strategy depends on state across restarts or redeploys.

Yes. A deployment can be started, stopped, restarted and redeployed from the TradingHost dashboard.

Yes, provided your repository structure and deployment configuration make each strategy entry point clear. Each deployment should specify what it is intended to run.

No. Your strategy code connects to the broker or exchange and sends orders according to your logic. TradingHost provides the runtime and deployment layer.

Yes. TradingHost is designed for MCP-compatible workflows so supported AI development tools can inspect deployments, view logs and trigger redeployments where authorised.

Deploy your strategy from GitHub

Connect an existing repo or create one from a TradingHost template, configure your deployment, and launch your strategy into an always-on runtime.