Algorithmic Trading Research System

Context

Instead of researching one company or one trade, the way Gabriel was already doing for Junior Economic Club pitches and Han Insights, this project asked a different question: could he build the system that actually tests whether a strategy holds up? That meant scanning for setups, checking them against rules, and tracking what happened, before any of it touched a real decision.

The Question

Not “can this make money.” At 15, with no track record and no capital to responsibly risk, that’s not a question worth asking yet. The real question was narrower and more useful: can a system be built that’s honest about what it doesn’t know? One that refuses to act when it isn’t confident, instead of always producing an answer whether or not the answer is any good.

How It Works

Key Decisions

A few choices mattered more than the code itself:

• Fail closed, not open. If the system isn’t confident about a signal, it does nothing, rather than guessing and hoping the guess is right. This shows up as one of the 27 dated design decisions, not just a general intention.
• A hard ceiling on what any single position can risk. No amount of confidence in a signal removes the cap — the point of a cap is that it doesn’t bend.
• No crypto, no margin, no short-selling. Cutting out entire categories of risk on purpose, rather than trying to control for them individually, because the simplest way to avoid a mistake is to not create the opportunity for it.
• No performance numbers get published. Backtests and paper-trading results exist inside the project. Showing them publicly, even labeled as research, even from a system this early, risks reading as a claim about real returns — a claim this project can’t honestly make yet.

Challenges & Iteration

The system didn’t work correctly the first time, and the record of what went wrong is arguably more useful than the record of what went right. A few examples: at one point the system was reading the wrong starting value when it calculated its own gains and losses, which would have quietly thrown off every risk calculation downstream without ever looking obviously broken. Separately, a status label once reported the system as being in a safe, scan-only mode while part of it was still capable of acting — a labeling bug, not a logic bug, but the kind that matters most because it’s the kind a person trusts without checking. And a placeholder value that was never replaced silently dropped hundreds of symbols from analysis for a stretch, with nothing raising an error to say so.

None of these were caught by the system announcing a problem. They were caught by going back and checking. The same habit mattered at Rosati’s, applied here to code instead of a spreadsheet.

Where It Stands

The project is ongoing. It has a working scanner, signal layer, risk controls, backtesting pipeline, and a dashboard for reviewing all of it. But it stays what it’s supposed to be right now: a research tool for testing ideas rigorously against real historical data, not a finished product with results to report. No dashboard screenshots are shown here yet, either — nothing from it gets published until it’s been reviewed line by line for anything that shouldn’t be public.

Reflection

Most of what got built here isn’t the part that finds a good trade. It’s the part that says no to a bad one, or says nothing at all when it isn’t sure. Sixteen safety rules and twenty-seven written-down decisions are, mostly, a list of things the system is not allowed to do. Building that list turned out to be as much of the work as building what the system does. That part doesn’t show up if you only look at the finished dashboard.