We build
strategies, test them, and deploy them.
How we work
Most strategies never get past testing
Research, backtesting and production code are written in-house, and whoever wrote a strategy watches it trade.
- 01
Build
Ideas are prototyped in Python on AWS. The ones worth keeping are rewritten in C++20 for production, with the hot paths kept lock-free.
- C++17 and C++20
- Multithreaded, lock-free queues
- Signal and execution logic
- 02
Test
Each candidate is backtested in parallel across market regimes, then walk-forward and Monte Carlo tested with realistic costs. It moves on only if it holds up out of sample.
- Parallel backtests on AWS
- Walk-forward, out of sample
- Monte Carlo, costs, slippage
- 03
Deploy
A strategy that passes goes live on our master account, and the engine copies each trade into the client's own MT5 account. We watch every fill and latency figure as it happens.
- Tick-to-trade profiling
- FIX and broker connectivity
- Prometheus and Grafana
Once a strategy is live, its fills and slippage go back into research, and the next version is built on what the market actually did.
One engine, from backtest to live order
Engine architecture. Market data arrives over multicast and FIX into a feed handler, which passes it through a single-producer, single-consumer lock-free queue to the C++20 strategy core. Orders then pass pre-trade risk and the execution gateway, and are copied into each client's own MT5 account at their own regulated broker, outside the QuantFX engine. Research data feeds parallel backtests on AWS, and the ideas worth keeping are rewritten in C++20 for the strategy core. Every stage reports metrics to Prometheus, with dashboards and alerts in Grafana.
- order path
- research
- telemetry
Capabilities
- Tick-to-trade latency
- We measure the path from market data to order and remove the slow steps one at a time.
- Lock-free concurrency
- Threads hand data over through lock-free queues, so the hot path never waits on a mutex.
- Connectivity
- TCP and UDP multicast market data, and FIX sessions to venues and brokers.
- Parallel backtesting
- Walk-forward and Monte Carlo runs spread across AWS workers instead of queued on one machine.
- Monitoring
- Prometheus collects metrics from every stage. Grafana alerts us when something drifts.
- Trade copying
- Trades are copied into each client's own MT5 account.
From the hot path
template <typename T, std::size_t N>class SpscQueue { static_assert((N & (N - 1)) == 0); // so % becomes & alignas(64) std::atomic<std::size_t> head_{0}; alignas(64) std::atomic<std::size_t> tail_{0}; std::array<T, N> buf_{}; public: bool push(const T& v) noexcept { const auto h = head_.load(std::memory_order_relaxed); if (h - tail_.load(std::memory_order_acquire) == N) return false; buf_[h & (N - 1)] = v; head_.store(h + 1, std::memory_order_release); return true; } // pop() mirrors push() on the consumer thread.};Companies license the engine
Elite Gold Academy is one of the companies that license the QuantFX engine and offer it to their own clients. The engine copies each trade from our master account into the client's own MT5 account. The client's broker executes it and holds the money.
QuantFX engine
Our strategies and execution code, run and monitored by us.
Licensee company
Elite Gold Academy and others. They own the client relationship.
The client's own MT5 account
Opened in the client's name and controlled by the client.
The client's regulated broker
Executes each trade and holds the client's money.
Client money stays here, at the client's broker.
Three ways to work with us
Engine licensing
Offer our strategies to your clients under your own brand. The engine copies each trade into their own MT5 accounts.
Discuss a licenceWhite-label infrastructure
We build bespoke strategies and a copy engine for your company, then run and monitor them for you day to day.
Talk about white-labelCustom quant development
Bring us a quant or C++ project, such as a strategy, a backtester or an execution component, and we build it to your spec.
Bring us a project
Who builds the engine
QuantFX was founded by Aaron Corky J, who has spent a decade trading live markets. He holds a funded-trader record across four proprietary trading firms and trained in quantitative modelling with Wharton Online at the University of Pennsylvania.
That experience is why the engine checks daily loss, total drawdown and open positions before every order.
Credentials
Finance and Quantitative Modeling
Wharton Online, University of Pennsylvania
Network Design
Cisco
Diploma in Strategic Management
IBMI
Funded-trader track record
Four proprietary trading firms
Track record of the master strategy account
The engine we license trades this account. Results are recorded trade by trade in MT5; shown here as month-end figures.
- Account growth
- +1,454.6%
- Net P&L
- $56.7M
- Average monthly profit (% of $3.9M start, 2025)
- +85.3%
- Profit factor
- 1.20
Our own account, run in a broker demo environment with live pricing. The balance is not client money and cannot be withdrawn. Past performance does not guarantee future results.
Full track recordTalk to us
Tell us what you are working on, or email info@quant-fx.com.
Investors: read the overview or download the deck (PDF).