Exporting & Going Live

TL;DR. Exporting turns your validated strategy into a self-contained executable that runs on a machine you control and connects directly to your broker. Your live trades never pass through AlgoLift's servers, your broker API keys never leave your machine, and if AlgoLift's web interface is down, your live strategy is unaffected. This is what "User Sovereignty" actually means.

What you'll be able to do

• Export a strategy that has cleared forward testing and run it on your laptop, desktop, or VPS.
• Connect it to your broker's API and have it trade autonomously, 24/7 if you want it to.
• Set up the monitoring, heartbeat, and kill-switch infrastructure that makes live deployment safe.

What it lets you do

Most platforms force you to trade on their infrastructure. Your strategy runs on their servers, your API keys live in their database, your live trades flow through their order router. That's convenient and it's also a single point of failure — and it means the company can see every trade you take.

AlgoLift's model inverts that. Once a strategy passes forward testing, you generate an executable — a self-contained program that includes your full node graph compiled into runnable code, plus the broker connector for the API you want to use. You run it on a machine you own; the executable reads ticks directly from your broker's market data feed and sends orders directly back. AlgoLift's web app is not in the loop for any of it.

Three implications worth being explicit about:

1. Your IP stays yours. Your indicator settings, your custom clusters, your secret sauce — none of it phones home from a running executable. The cloud research environment is a research tool; the executable is yours.
2. Your account credentials never touch our servers. Broker API keys are entered into the local executable when you launch it. AlgoLift never sees them and cannot see them, ever.
3. Platform risk is decoupled from live risk. If AlgoLift's dashboard is down for maintenance, your live strategy keeps running. If your VPS goes down, your strategy stops — and the kill-switch logic makes sure no half-state positions get stranded.

Where to find it

From any strategy that has cleared forward testing: Deploy → Export Live Executable. The export wizard walks you through platform, broker, and credentials setup.

Step-by-step

1. Pick the target

Three things to choose:

• Platform. Windows, macOS, or Linux. The executable is platform-native; pick the OS of the machine you'll actually run it on. Most futures traders pick Windows (broker tooling is more mature there); most crypto traders pick Linux (VPS is cheaper).
• Broker connector. The integrations supported today: Interactive Brokers, Tradovate, NinjaTrader, TopstepX (for funded accounts), and the major crypto exchanges (Binance, Coinbase, Bybit). The connector you pick is bundled into the executable — you can't switch later without re-exporting.
• Mode. Live trades real capital. Paper trades the broker's paper account. Always start in paper for the first 24–48 hours of live deployment, even after forward testing — the goal is to verify your broker behaves the way the forward test modeled.

2. Generate and download

The export takes ~30 seconds. You receive a single executable file (and on Windows, a small launcher script alongside it). No installer required, no admin permissions needed — the file is self-contained and portable.

3. Run it locally

On your target machine:

1. Place the executable somewhere persistent (not your Downloads folder).
2. Launch it. The first launch opens a config window asking for your broker API key, secret, and account ID.
3. Confirm the symbol, position-size limits, and daily kill-switch threshold.
4. Click Start.

The executable opens a status panel showing the live tick stream, current position, current P&L, heartbeat timestamp, and recent log entries. It will sit and wait until your strategy's logic fires, then trade.

4. Set up monitoring

A running executable that you can't see is a running executable you can't trust. Two layers:

• Local heartbeat. The status window updates every tick — if the timestamp stops advancing for more than 30 seconds, something is wrong (lost connection, broker outage, machine sleep).
• Remote heartbeat. Configure the executable to ping a webhook URL every N minutes. Point that webhook at any uptime monitor (UptimeRobot, Better Stack, your own server). If two consecutive pings are missed, you get a phone notification.

The monitoring & incident response page covers the full playbook — alerts, escalation, and what to actually do when something fires.

5. Set the kill-switch

The executable ships with three kill-switches you should configure before the first live tick:

• Daily loss limit. A dollar amount. If your day's PnL drops below it, the executable flattens all positions and stops trading until you re-enable it manually.
• Max position size. A hard cap, even if your strategy's logic asks for more. Catches calculation bugs and prevents runaway sizing.
• Manual kill. A keyboard shortcut (and a webhook endpoint) that immediately flattens and stops. Test this on day one in paper mode.

For prop-firm accounts, the daily loss limit must match (or be tighter than) the firm's rule. The prop-firm traders use case walks through the exact numbers.

Where to run it

The choice that matters most after the strategy itself:

For the vast majority of users, a $10/month VPS near your broker's data center is the right answer. The latency drop alone usually pays for the VPS in the first month.

Configuration reference

Tips and pitfalls

• Do start in paper mode for 24–48 hours. Even after a clean forward test. The forward test was AlgoLift's fill model; the broker-paper test is the actual broker's fill behavior. They're close but not identical.
• Do compare the first week of live fills against your forward-test fills. Small differences are normal. A systematic 3+ tick difference means your broker's behavior diverges from the model and you should account for it.
• Don't share executables. They contain your compiled strategy logic. If someone has the binary, they can run your strategy on their account — and you have no way to revoke that.
• Don't run two copies pointed at the same broker account. They'll both try to manage positions and the resulting double-trading is one of the most expensive bugs in systematic trading.
• Don't ignore the log file. When something goes wrong, the answer is almost always already written in there.

How this fits the workflow

This is the last step. Design in the Visual Builder, validate in the Backtest Engine, interpret in Analytics, combine in the Portfolio Builder, watch on real data in Forward Testing, and finally export here. The deeper deployment treatment lives in the Level 4 live deployment and security & compliance pages.