QORE is an event-driven system, multitenant by design, with separate layers for feed, indices, strategies, execution and data. Each component does one thing. Every decision is traced, every execution is reconstructable.
One single pipeline. The same code runs in production and in backtesting: no divergence between simulated and real. Optimisation and operations live in the same environment.
Capture of institutional-grade order flow, tick after tick, with automatic switch to the new contract at rollover. Everything is archived.
The system measures each instrument's volatility objectively and interprets its regime: values that are comparable across different markets.
The reading of the market adapts to the regime: finer when calm, wider when explosive. Noise is contained, not chased.
Strategies read the footprint bar by bar and produce a signal. One engine per symbol, one shared global signal.
One instance per client turns the signal into execution: sizing, normalised protections, a single active protection per symbol. No competing orders.
Interactive Brokers today, multi-broker by design: an abstraction layer isolates the platform from the broker, so changing it doesn't touch the logic.
Tap a block to jump to its section.
MED is our main strategy: it reads the smallest signals of the order flow — the ones retail platforms don't see — and enters only when the market confirms. It's a deep strategy, built to catch what a surface reading misses. No resting orders: you enter only on evidence.
It analyses order flow in the finest detail, tick after tick, following each bar's evolution up to the entry point.
The position opens only when several independent signals agree on direction. No predictions: it acts on evidence.
It spots the prices where institutional operators defend their positions, and positions in their wake, not against them.
A dedicated engine reconstructs in real time the references every professional desk actually watches — the session's average price, the areas of heaviest trade, the highs and lows of previous days. When a defended level coincides with one of these, the confirmation raises the signal's confidence.
It recognises the orders institutions try to hide on the book: the hardest signal to fake, because showing it costs real money.
Maximum entry distance, time windows, cooldown after a stop, alignments: each client calibrates their own emission filters.
Each instrument has its own analysis engine, producing a single global signal served to all clients in the same way.
QORE measures volatility objectively, instrument by instrument, and adapts both its reading of the market and its protections accordingly. The same principle used by institutional regime-detection systems, made configurable by the client.
Each instrument is measured against its own normal, per symbol and per session. Different markets become directly comparable, on a base that updates daily.
The system adapts its pace to the regime: reactive when the market is calm, cautious when it explodes. It doesn't chase noise, it contains it.
A dedicated sensor recognises anomalous conditions and blocks new entries before they turn into losses. The sensor's silence is treated as an alarm, never as a green light.
Stops and targets are expressed in proportion to each instrument's typical volatility, not in fixed values: the same relative risk on every symbol, present and future.
Market volatility is an objective fact; what to do with it is a style. QORE provides the measure — clean, per-instrument, up to date — and leaves the interpretation to the strategy, and to the client.
The chart's bars aren't born at fixed intervals: their size is decided, bar after bar, by the state of the market. A matrix crosses two readings — how much the price is moving and how much energy is in the flow — and from that crossing determines how large the next bar will be. The same principle used by institutional regime-detection systems, made configurable by the client.
The size of the next bar comes from crossing the price regime with the energy of the flow: two objective measures, combined into a single choice.
When the market is quiet, bars become small: maximum reactivity on the micro-movements, where the signal is born.
When the market accelerates, bars widen: noise is contained, not chased. The system isn't overwhelmed by volatility.
The same reading of the market can translate into different bars for different styles: the matrix is editable by the client and distinct per session, and the value stays locked for the entire duration of the bar being built. The reading is objective; how to use it is a choice.
Strategies publish signals, never orders. Execution belongs to a central orchestrator per client: no competing orders, no accidental fills, a single source of truth on risk.
From the moment of entry, a stop protects the position. Maximum capital preservation until the trade establishes itself.
Once a profit threshold is reached, the stop moves to entry: from here the trade can no longer close at a loss.
The stop follows the price at a constant distance and captures the move while it continues. It chases the peak, never retreats.
Each update modifies the existing order on the broker instead of cancelling and recreating it: never an instant without protection on the market.
Every future has an expiry, and the switch to the next contract is one of the points where retail trading breaks most often: orders left on a dead contract, orphaned positions, sizes computed on the wrong instrument. The big losses in retail don't come from the strategy — they come from here.
The switch happens when liquidity has actually moved to the new contract, not on a calendar date — and in a quiet market.
First a warning to the whole system, then cancellation of pending orders and closure of positions on the old contract. Only then does the new one become the reference.
The switch propagates to all linked contracts, standard and micro together. No expired contract stays attached to the system.
Same strategy code live and in backtest, on a distributed cluster. First you explore quickly to see what works, then you validate at maximum fidelity: no go-live without validation.
Large parameter spaces are tested quickly, to narrow the field to what's worth exploring further.
Orders are matched against the market actually recorded: slippage and conditions are the real ones, not an approximation.
The simulation reconstructs the entire system — indices, protections, safety gate — exactly as in production.
The final validation reproduces a market day at maximum fidelity, order by order, before authorising real operations.
The fidelity of our backtesting rests on a resource no one else has: we record the markets' order flow, tick after tick, from day one. It's an unavailable collection — no commercial feed sells it — and unbuyable: whoever didn't record it in real time will never recover it. It grows every market day, and with it our edge. A precious rarity that is, simply, ours alone.
Strategies analyse the flow once and produce a global signal. Each client has their own execution instance: separate configuration, separate account, total data isolation.
A single analysis engine per symbol serves all clients: the quality of the signal doesn't depend on the number of users.
Parameters, protections, sizing and accounting fully isolated per client. Everyone sees only their own P/L.
Invitation, registration with mandatory two-factor authentication, broker configuration with encrypted credentials.
Feed, indices, strategies, execution and data run on separate hosts. A failure in one layer doesn't propagate to the others.
Emergency button in the dashboard: all positions closed at market, all strategies disabled, recorded in audit.
Automated trading doesn't fail with an error: it fails in silence. A dedicated system watches every component of the platform — heartbeats, metrics, logs and events — and turns silence into an alarm. If a critical component stops reporting, the gates close before a wrong order can go out.
Margin is always verified at the broker before every order. If the check fails, the system blocks new entries.
Every release first goes through a test environment identical to production. Only after passing the checks is it promoted.
Full architectural documentation is available to technical partners and institutional clients, under NDA. Contact us to request it.
