StrategyHub

Built for the hours you can’t watch the market.

Comment

Inspiration

It started because of my dad.

I used to see him spend hours looking at his screen with green and red stuff , moving between different tabs, checking charts, opening Long and Short positions, and managing several strategies at the same time all manually. Even when he had a clear strategy, he still had to stay close to the screen and wait for the right conditions. Even when he already knew what Strategy he wanted to follow, he still had to keep watching the market. If he went to sleep and the Strategy conditions happened while he was away, he could miss the opportunity and possibly lose money

One day, he asked me:

“Jory, you know programming and how to use AI, right?

I said yeah I do, and he asked me how it could help him with his work. We kept talking, and that conversation became the beginning of StrategyHub.

Why couldn’t I help my dad do his work more easily and be more productive? He could spend less time watching the market, get better sleep, and I would get to see him more. He could also track how much he earned and understand which Strategies were the most effective

When I told him the idea, he started sharing more about what he would like to see in the app. app. As we continued talking, I added more and more features based on the problems he faced in his normal trading workflow .

One of the features he liked the most was Opportunities

In the past, he used to search manually for coins that might work with one of his Strategies . This was boring where he used to search manually for coins that might work with one of his Strategies. This took a lot of time and effort. He had to look through different coins, open their charts, study their movement, and decide whether each coin was suitable

After choosing a coin ,either manually or through the Opportunities page, he could use Backtesting to test his Strategy on that specific coin before running the bot.

The project made the workflow more automated and faster for him :

Create a Strategy → adjust its values and variables → find Opportunities → Backtest it → run the bot

He can also ask Codex to help implement a new Strategy he has in mind. I even taught him how to use Codex himself ( I will explain more about that later ) .

I wanted to build something that could reduce his workload, help him manage his Strategies more easily, and allow him to spend less time watching the market.

What it does

StrategyHub is a local trading workspace that brings Strategies, market monitoring, Orders, Positions, performance, and Risk Management into one place.

Instead of managing everything manually across different tabs, the user can create and manage multiple Strategy Instances, choose which coins they work with, adjust their settings, monitor their status, and decide when to run or stop them.

StrategyHub supports three separate environments:

  • Paper for testing with simulated money
  • Testnet for testing through Gate.io without using real funds
  • Live for real trading with additional confirmations and safety checks

It also includes:

  • Opportunities, which helps find coins that may suit a Strategy
  • Backtesting, which tests a Strategy against historical market data
  • Manual Market and Limit Orders
  • tracking for open Orders and Positions
  • live and historical performance information
  • PnL, Win Rate, Drawdown, and Trade history
  • Take Profit, Stop Loss, and trailing protection
  • daily Equity-loss, losing-trade, and automatic-entry limits
  • an Emergency Stop that blocks new entries
  • Account and exchange reconciliation
  • backups and recovery tools

Before an Order is submitted, StrategyHub creates a detailed Preview showing information such as:

  • Entry price
  • Quantity
  • allocated Margin
  • leverage
  • estimated fees
  • Take Profit
  • Stop Loss
  • liquidation estimate
  • whether the Account and environment are ready

When an Order is blocked, it does not only show a general error. It explains the exact reason, such as missing Credentials, incomplete synchronization, stale market data, invalid Quantity, insufficient balance, or a reached risk limit.

StrategyHub is not meant to choose a Strategy for the trader or replace their judgment. It handles repetitive work, keeps everything organized, and gives the trader clearer control over what the system is doing.

How I built it

StrategyHub was built as a local Windows application with a Python backend and a React frontend.

The backend is responsible for the important trading logic, including Strategies, Orders, Positions, Account state, Risk Management, Backtesting, exchange communication, and deciding whether an action is safe to perform.

The frontend is the control panel where the user can manage Strategies, view Opportunities, run Backtests, track performance, open Manual Orders, and see why an action is ready or blocked.

The main technologies we used are:

  • Python 3.12
  • FastAPI
  • Pydantic
  • SQLAlchemy
  • Alembic
  • SQLite
  • HTTPX
  • WebSockets
  • React
  • TypeScript
  • Vite
  • Pytest
  • Vitest
  • Ruff
  • Gate.io APIs
  • PyInstaller
  • Inno Setup
  • WinSW

I used GPT-5.6 throughout the project to help me think through the product, understand trading concepts, review the user experience, find weak points, and turn my ideas into clear technical requirements.

This was especially useful because I was still learning many trading concepts while building the app. When I did not understand something, I asked questions until I understood how it should actually work before asking the coding agent to implement it.

I used Codex as the main harness agent in addition to ChatGPT. It helped inspect the repository, trace how different parts of the project were connected, implement backend and frontend changes, create database migrations, add tests, fix bugs, and review the code.

Instead of asking Codex to change everything at once, I divided the work into smaller milestones.

For each milestone, the process was usually:

  1. Inspect the existing implementation.
  2. Identify the problem and the affected parts of the project.
  3. Write clear requirements and safety rules.
  4. Implement the change.
  5. Add or update tests.
  6. Run backend and frontend checks.
  7. Review the changes.
  8. Save the work in a focused Git commit before continuing.

Of course I used some skills here and there including once on the above workflow

The app was entirely made during the period 13-21 of July expect for initialising the project on 12 of july.

But Some of the most important Build Week changes included:

  • creating one authoritative system for Paper, Testnet, and Live environments;
  • preventing the interface from showing one environment while the engine was using another;
  • replacing failed or confusing Order Previews with structured validation messages;
  • moving exchange reconciliation into a faster background process;
  • adding immutable daily Equity baselines for Risk Management;
  • adding separate Enable/Disable controls for each daily limit;
  • verifying the full Paper trading lifecycle;
  • testing the Testnet lifecycle through controlled production API boundaries;
  • separating built-in Strategy Templates, saved Presets, and Strategy Instances.

I also packaged StrategyHub as a Windows application with a local background engine, so the user can install and open it without manually starting Python or the frontend.

Challenges we ran into

The biggest challenge was that I honestly knew almost nothing about trading when I started.

The app first started as a simple Python bot for only one Strategy, So while building StrategyHub, I also had to learn trading at the same time. I learned a lot of concepts, even started trading myself so I could understand my dad and the bot better ,and tried to understand more about how my dad works and what he actually needs from the bot.

As time passed, my dad started asking for more things. The project slowly changed from one simple Strategy bot into the bigger app it is now, with multiple Strategies, Opportunities, Backtesting, performance tracking, Risk Management, Paper, Testnet, Live, and the other features.

The first version was also only a Python app without a web interface. At first that was enough, but when the project became bigger, it was not really effective anymore. It became difficult to manage different Strategies and see all the information clearly, so I later added the web interface and continued developing the app into its current form.

Another challenge was that my dad did not know much about AI or how to use AI coding tools. I had to teach him how to use Codex, how to explain the Strategy he wanted, and how to write a proper prompt so Codex could understand it and implement it.

it was not really effective anymore. It became difficult to manage different Strategies and see all the information clearly, so I later added the web interface and continued developing the app into its current form.

Another challenge was that my dad did not know much about AI or how to use AI coding tools. I had to teach him how to use Codex, how to explain the Strategy he wanted, and how to write a proper prompt so Codex could understand it and implement it.

Basically, my dad understood the trading side and knew what he wanted, while I understood programming and AI more. A lot of the work was learning how to connect both sides together.

Accomplishments that I’m proud of

The thing I am most proud of is how much StrategyHub grew from where it started.

At first, it was just a small Python bot made for one Strategy my dad wanted. Now it has become a full app where he can create and manage different Strategies, find Opportunities, Backtest them, track Orders and Positions, view performance, and run everything from one place.

I am also proud that I did not just build the app based on assumptions. I kept showing it to my dad, listening to what he needed, and adding or changing features based on how he actually trades. Seeing him get excited about features like Opportunities made me feel that I was building something that could really help him, not just another random project.

Another thing I am proud of is that I started this project knowing almost nothing about trading. I had to learn a completely new field while also building the app. I even started trading myself so I could understand the problems better and make better decisions while developing StrategyHub.

I am also proud that I taught my dad how to use Codex. Now, when he has an idea for a new Strategy, he can explain it to Codex and work on turning it into something the app can support. It is nice seeing him become more comfortable with AI and use it for something that actually matters to him.

(he even made his own bots and projects and used them to trade . they are actually great too ! He eventually upgraded to the plus plan because he liked codex )

On the technical side, I am proud that StrategyHub now has separate Paper, Testnet, and Live environments, along with Order Previews, Risk Management, Backtesting, performance tracking, and safety checks that explain why an action can or cannot happen.

Most importantly, I am proud that something which began as a simple request from my dad slowly became a project built around making his work easier, faster, and less tiring.

What we learned

The biggest thing I learned was trading itself , and improving my vibe coding workflow .

When I started, I barely understood most of the terms my dad was using. While building StrategyHub, I learned how Orders, Positions, Long and Short trades, Margin, leverage, Take Profit, Stop Loss, Backtesting, and Risk Management actually work.

I also learned that understanding the user matters as much as writing the code. A feature can technically work but still not be useful or easy to use. A lot of StrategyHub changed after I watched how my dad worked, listened to his feedback, and understood what was slowing him down.

Another thing I learned is that a project can grow far beyond its original idea. StrategyHub started as a small Python bot for one Strategy. As my dad asked for more features and I understood his workflow better, it slowly became a much larger app.

I also learned how useful AI can be when it is used correctly. GPT-5.6 helped me understand concepts, think through problems, organize ideas, and review the app. Codex helped me turn those ideas into code, find problems across the project, add features, and test them.

But I also learned that you cannot just give an AI a vague request and expect the perfect result. You need to explain what you want clearly, check what it builds, test it, and keep improving the prompt when something is misunderstood. This is also something I had to teach my dad when showing him how to use Codex for his Strategies.

Most importantly, I learned that I do not need to know everything before starting. I started with almost no trading knowledge and a very small app, then learned and improved it step by step.

I also improved my workflow when making vide coded projects and had way better results than my other projects , both because of 5.6 and the skills and my new workflow

What's next for StrategyHub

The next step is to keep improving StrategyHub based on how my dad actually uses it.

There are still parts I want to make simpler and better, especially Strategies, Opportunities, Backtesting, and the way results are shown. I also want the app to work better on phones and tablets because my dad will not always be using it from a computer.

one of the main ideas I want to work on next is adding AI to StrategyHub for a couple of reasons.

First, I want the user to be able to describe a Strategy inside the app in normal words, and then have the AI help turn it into an actual Strategy. This would be much easier than having to leave the app, write a full prompt for Codex ( which many people don’t write a proper one) , the ai brainstorm with him and ask the user questions , and manually add the Strategy every time.

I also want the AI to help the user understand their trading results. It could track profits and losses, compare different Strategies, explain which ones are performing better, and point out where most of the losses are coming from.

It could also:

  • explain Backtesting results in a simpler way;
  • suggest values or settings that may be worth testing;
  • compare how a Strategy performs on different coins and timeframes;
  • find patterns in winning and losing trades;
  • warn the user when a Strategy is behaving differently from its Backtest;
  • explain why an Order was blocked or why a Strategy stopped;
  • summarize daily or weekly performance;
  • suggest possible Opportunities based on the Strategies the user already has;
  • help the user understand the risks before running something in Live.

The AI shouldnt blindly trade or make every decision for the user. I want it to work more like an assistant that explains what is happening, suggests things to look at, and helps the user make a better decision.

Another important step is more testing. Paper mode is the safest way to test the full workflow, and after that I want to carefully test everything using Gate.io Testnet before depending on any Live features.

I also want to improve the Windows installer, the in-app guide, backups, and recovery, so my dad can use StrategyHub without needing me every time something needs to be installed, fixed, or explained.

Most importantly, StrategyHub will continue growing through conversations with my dad. The project started with one Strategy he wanted, and most of its features came from problems he faced while trading. I expect the next features to come in the same way: he uses it, tells me what is missing or confusing, and I continue making it better for him.

Built With

Share this project:

Updates