← Trading Systems
Private platform · Research → production

Futures Quant Pipeline — Research to Live Execution

A systematic-futures research platform in Python and its live execution layer in C++ (Sierra Chart / ACSIL), built as two halves of one system: a strategy that survives research is frozen as a JSON model and reproduced bar-for-bar, trade-for-trade by the live study — proven with bit-level parity gates before a single real order. The platform's real product is unbiased backtests: a no-lookahead contract enforced by CI, random-noise controls on every result, and a promotion path ending in exact reconciliation between research and production.

Python 3.12 pandas / NumPy numba (JIT) C++17 / ACSIL Sierra Chart pytest CI gates
~334k
lines of Python across 1,176 files (research platform)
~90k
lines of C++ across 116 files (execution layer & studies)
~70
strategy families researched across six futures markets
0.000000 R
total portfolio difference at the research↔live parity gate

The research platform

Every strategy family runs through one shared, contract-enforced pipeline from raw bar data to a result tree with full provenance. (The signal logic itself stays private — what's shown here is the machinery around it.)

Stage A → B → C pipeline

  • Stage A generates entries and attaches signal families, each registered with exactly which bar it may read; Stage B screens and ranks on out-of-sample performance; Stage C runs a numba-JIT sweep over a six-figure count of configurations.
  • A mandatory family rollup reports the family median, not the sweep's max — the anti-cherry-picking rule.
  • One command runs the whole chain with a single exit contract threaded through every stage.

Risk & exit modelling

  • Volatility-adaptive stops and laddered targets; exits resolve on a finer data stream than entries — a coarse-only backtest grants artificial "free-bar immunity" worth more than some strategies' entire edge.
  • Path-dependent exit rules must qualify before they may trigger; unqualified variants exist only as controls.
  • Finalists face a 5-check validation battery: structural drill, neighbour stability, ~18 rolling OOS cuts refit per cut, and one untouched holdout reserved before selection.

Guardrails that stop backtests from lying

The defining feature is not the strategies — it is the machinery that makes a good-looking result hard to fake. Most commits in the log record a refutation, written into the run ledger and turned into a permanent, tested rule.

The no-lookahead contract — enforced at runtime

A per-entry-style table defines which bars a feature may read, backed by a runtime validator that NaN-patches every entry's anchor bar and asserts the outputs are unchanged — a signal that notices the NaN is reading its own entry bar. CI includes tests proving the validator itself catches planted lookahead.

Entry styleBar i state at fillFeatures may read
Level/touch entry (fill intrabar on bar i)still formingbars ≤ i−1 only
Close entry (fill at C[i])completebars ≤ i
Next-bar-open entry (fill at O[entry_bar])not startedbars ≤ entry_bar−1

Random controls as a mandatory noise floor

  • Stage A seeds 20 information-free random signals that pass through the identical screen, decorrelation and full sweep; verdicts come with a Mann-Whitney p-value.
  • Results split three ways — pure-real / mixed / all-control — because a real+control combination is neither evidence nor a clean control. Getting this wrong once forced a retraction; the fix is now a tested rule.
  • Exit variants with a known optimistic bias are demoted to control-prefixed variants that structurally cannot be ranked, promoted or frozen.

Provenance & immutability

  • Caches carry a fingerprint of their inputs — changed inputs produce a new file; deleting a cache or result tree is a merge-blocking test failure.
  • Result trees chain run tags folder-to-folder, and every runner appends a one-line objective to a per-strategy run ledger.
  • Research bars are a pinned vintage, physically separated from the live tree that advances nightly.

Promotion to live — parity before orders

A finalist is frozen as a production JSON artifact, specified in a model document, and re-implemented as a C++ study. Nothing is trusted until proven equal.

Parity ladder

  • Gate zero: bar-stream parity. Features are never diffed until the bar streams are proven identical — one one-bar disagreement measurably re-ordered downstream features.
  • ~19 numeric feature kernels each proven bit-identical against their Python reference; a ~1e-7 residual is treated as a float32 signature — "find the narrow type, never widen the tolerance."
  • Full-stack trade comparison: the promoted portfolio passed at 100.00% with 0.000000 R total difference.

Live order layer

  • A single submission choke point is the only buy/sell call site; every accept and refuse goes to an append-only order-event journal.
  • Server-side bracket children at absolute prices; feature state survives restarts via a CRC-checked snapshot with atomic publish that fails closed.
  • A stale-level guard — born from a live post-mortem of three tickets filled in the same second after a restart — refuses already-invalidated entries, implemented as pure functions a console probe can test with no Sierra Chart running.
  • A nightly watchdog classifies every trade-service event as benign, explained, or a true reject — alerting before the next open.