Ticpoz Back to site

From idea to live trade in twelve minutes

A walkthrough: describe a strategy in plain English, backtest on real tick data, deploy to your broker, and watch the first trade fire.

Last updated · 2026-05-13

This is a walkthrough of the fastest path through TICPOZ. Twelve minutes is not a marketing number; it is what we timed on a fresh signup last week, end to end, with a strategy idea someone in our Discord typed out informally. Your mileage will vary, but it should not vary by much.

The strategy we used as the example: "Buy when the 5-minute RSI on XAUUSD drops below 30 but only if the 1-hour EMA50 is sloping up, exit on RSI above 60 or after eight hours, skip the trade entirely if a high-impact USD news release is within thirty minutes." Nothing exotic. Nothing tuned. Just a clear set of rules in plain language.

Minute zero to two: signup and broker connection

Signup is email and password, with strong server-side hashing on the password. You verify your email with a six-digit code. At this point your account has no broker attached and you cannot place trades. That is intentional. We want the broker connection to be a deliberate step, not a side effect of signup.

From the dashboard you click “Connect broker” and pick from cTrader, MT5, or a prop-firm account. cTrader uses OAuth — you authenticate on the broker's own login page and return with connection tokens that we encrypt at rest. MT5 uses a code-signed local bridge plus API credentials. Either way, you grant trade-execution permission but not withdrawal permission. We cannot move money out of your account.

While the broker handshake completes, our backend allocates your dedicated outbound IPv4 address. By the time the dashboard refreshes, your outbound trade traffic is bound to that address for the lifetime of the account.

Minute two to five: describe the strategy in Quant-AI

Quant-AI is the natural-language interface to our strategy compiler. You type a description in roughly the form a trading mentor would write it. Behind the scenes, a frontier language model translates your description into the platform's structured strategy format. You do not need to know which model. You need to know that you type English, and you get back a validated, executable spec.

For the example above, the resulting `StrategySpec` JSON contained:

  • An entry block with a 5-minute RSI condition (`rsi(period=14) < 30`) and a 1-hour trend filter (`ema(50)` slope positive over 3 bars).
  • An exit block with two clauses: 5-minute RSI above 60, or position age greater than 8 hours.
  • A news-avoidance block referencing ForexFactory high-impact USD events with a plus-or-minus 30 minute window.
  • Position-sizing rules with a 0.5 percent equity-at-risk default, configurable.

You read the spec. If it does not match what you meant, you edit your prompt and try again. Quant-AI is deterministic enough that the same prompt produces the same JSON, but small phrasing changes (RSI threshold of 30 vs. 32, "high-impact" vs. "any USD news") map cleanly to spec changes. This is the loop most people spend two or three minutes in.

The compiler is honest, not magic
Quant-AI will refuse to compile prompts that ask for things the platform cannot honestly do — guaranteed returns, "always profitable" rules, strategies that ignore drawdown. It will also refuse to compile strategies that look like grid-martingale doubling, because the failure mode is too sharp to backtest faithfully. If you hit one of these refusals, the message will explain why.

Minute five to eight: backtest

You click "Backtest" and pick a window. The default is six months of recent history. The backtest engine pulls real broker tick data from the venue your account is connected to — not synthetic candles, not aggregated EOD, actual ticks at the resolution the broker records them. Spreads come from the venue. Slippage models are calibrated against observed fills on similar instruments.

Six months of XAUUSD ticks is roughly thirty million events. The backtest runs in parallel across a CPU pool and returns in about ninety seconds for a strategy of this complexity. Heavier strategies, multi-instrument portfolios, or longer windows take longer. We display a progress bar with an estimated finish time that is usually within ten percent.

The results panel shows:

  • An equity curve with a clear ILLUSTRATIVE badge in the corner.
  • A trade log, every fill, downloadable as CSV.
  • Metrics: hypothetical net return, hypothetical maximum drawdown, illustrative win rate, illustrative Sharpe. Every label has "illustrative" or "hypothetical" attached because that is what they are.
  • A walk-forward panel showing how the strategy would have performed on a held-out tail of the data the parameter selection did not see.
  • A spread-and-slippage breakdown showing how much of the hypothetical return came from tight spreads in particular sessions.

Read it carefully. If the equity curve looks too clean, it usually is. We have a separate post on backtesting honestly that goes deeper into what to look for.

Minute eight to ten: deploy

If you like what you see, you click "Deploy". A few things happen behind the scenes.

  • We allocate a per-user isolated worker and load the compiled strategy onto it.
  • We bind your dedicated outbound IPv4 to that worker's outbound interface.
  • We open a streaming connection from the worker to your broker, authenticated with a freshly decrypted access credential. The credential never touches the front end.
  • We start streaming tick data into the strategy runtime. The strategy is now live, in the sense that it is evaluating its entry conditions on real ticks. It has not placed a trade yet — it is just watching.

At this point the dashboard shows a live equity-curve panel that ticks in real time, plus a panel showing the current values of every input the strategy looks at (RSI, EMA slope, next news event, current spread). You can pause, edit, or kill the strategy from this panel at any time.

Minute ten to twelve: the first trade

In the demo run we did last week, the RSI on the 5-minute XAUUSD chart dipped below 30 about seven minutes after deploy. The 1-hour EMA50 was sloping up. There was no high-impact USD news in the window. The strategy fired. The trade appeared in the broker's terminal within 200 milliseconds of the entry signal. The dashboard logged the fill, the spread paid, and the position size — all calculated from the live broker response, not predicted.

Twelve minutes from "sign up" to "first live trade". That is what we timed.

Your strategy, your trade
Read this carefully. The trade above was the user's trade, executed against rules the user wrote. TICPOZ did not pick XAUUSD. TICPOZ did not pick RSI as an indicator. TICPOZ did not pick the 30 threshold. The user picked all of those. TICPOZ just enforced them. If the trade had moved against the user, it would have been the user's loss, and TICPOZ would not refund anything. Your strategy, your risk, your trades.

What this does not show

Twelve minutes is the path for the simplest case: a clean instrument, a small strategy, an account that is already funded, no rule-set complications. Real workflows often add steps. Multi-instrument portfolios add a portfolio-construction step. Prop firm accounts add a rule plugin selection. Complex strategies with custom indicators add a debugging loop.

We are not promising that every strategy gets to live trade in twelve minutes. We are showing that the path exists and that the friction at each step has been worked out.

The closing thought

Most retail algo platforms make the first hour painful, and that is where most people give up. Our goal is the inverse: get you to the moment of truth — your strategy, on your account, evaluating real ticks — as fast as we honestly can, and then make the slow work, the iteration on the strategy itself, the part where you spend your time.

The strategy is the hard problem. We refuse to make the plumbing also the hard problem.