QuantPilot

Inspiration

What it doesInspiration

Retail traders fundamentally suffer from geometric capital decay not because of a lack of execution opportunity, but due to the absence of institutional risk-management paradigms. In addressing this hackathon's "mentorship connection problem", we realized that algorithmic systems operate as the ultimate mentors. Our inspiration for QuantPilot was to bridge the gap between emotional heuristic trading and deterministic risk algebra by building an educational, high-fidelity quantitative simulation engine that forces students to respect statistical failure boundaries before they ever risk real capital.

What it does

QuantPilot is a simulated execution environment and mathematical validation engine tailored for CME Micro Gold Futures (MGC1!). Instead of blindly taking discretionary trades, the application algorithmically backtests a macro-trend Dual-Session (Asia/New York) breakout strategy across historical constraints. It maps raw historical execution vectors onto a custom Next.js TradingView interface while simultaneously running a Triple Monte Carlo Simulation Kernel to calculate the exact, granular probability-of-ruin against standard Prop Firm evaluation metrics.

How we built it

The architecture is split into a robust Python data pipeline and a React-based interactive deployment boundary:

Data Ingestion: We aggregated over 16 years of MGC1! tick data via Databento, parsing Zstandard compressed raw streams to assemble an aggregated, deduplicated True-UTC OHLC matrix.

Mathematical Boundary (The Mentor): We wrote a Python engine implementing three extreme-volatility arrays: Standard Bootstrap, Exact Resampling, and Gaussian Markov Chains. This runs 30,000 independent cycle permutations natively against the strategy payload to project absolute drawdown parameters. The Interface: We transitioned the visualization into a pure Next.js 14 environment utilizing Tailwind CSS for a premium, pitch-black institutional aesthetic. We hooked TradingView's lightweight-charts directly into our execution arrays, mapping theoretical strategy entries as procedural pixel markers on the exact timestamp array. Challenges we ran into Execution Engine Latency: Attempting to render multi-year, minute-by-minute tick matrices natively in a browser context triggered immense memory heap overflows. We resolved this by engineering a strict server-side 7-Day Rolling Data Window constraint, guaranteeing sub-millisecond Next.js DOM refreshes without sacrificing terminal depth. Chronological Alignment: Merging raw Databento UTC Unix epochs against the strict America/New_York Exchange hours demanded by the TradingView canvas required writing custom offset localization scripts to prevent sub-pixel visual aliasing and ghost-candles. Accomplishments that we're proud of We are incredibly proud of isolating the 99th-percentile Max Drawdown vector to mathematically calculate to exactly -$1,180 across 30,000 randomized permutations. By plotting these constraints on an interactive React dashboard, the simulation mathematically proves absolute structural survival against traditional $2,000 prop-firm evaluation thresholds. We completely eliminated mathematical guesswork from the execution pipeline.

What we learned

We vastly expanded our understanding of high-frequency data structures, specifically processing raw institutional Level-1 data formats on the backend. We also integrated advanced mathematical concepts surrounding the probability of ruin, $P(R) = \left(\frac{q}{p}\right)^C$, applying stochastic calculus to evaluate whether a localized strategy edge ($p > q$) statistically compounds or fails inside a defined capital constraint ($C$).

What's next for QuantPilot

Currently, QuantPilot operates as a deterministic educational mentor running entirely on simulated offline arrays. Our immediate roadmap involves building secure Node.js API Webhook listeners to bridge active Pine Script signal calculations over the internet. This will allow us to transition the theoretical simulation into a live execution adapter, securely interacting with Tradovate and Interactive Brokers REST APIs through an encrypted OAuth handshake.

Built With

• api
• database
• montecarlo
• nextjs
• numpy
• pandas
• python
• react18
• tailwind
• tradingview
• typescript