Home / Work / Vector Games

Trading education and simulation

A trading school built as a game, on simulated prices.

A trading school and practice desk on simulated prices: lessons, a journal and games that reward process, with trader data walled off. Education, not financial advice.

Visit vector-games-vg.netlify.app Build something like this

Six feature cards for the Vector Games desk

Who it is for: People who want to learn trading rules and build habits before they risk any money.
The problem: Most people learn to trade by risking money before they have a process, and profit-based leaderboards reward luck.
What they get: Short lessons, a realistic practice desk on simulated prices, a trade journal, and rank earned for discipline. Education only, with no claim about results.

10Academy units

51Played lessons

9Mini-game types

7Rank tiers

23Paper markets

The challenge

Vector Games is education and simulation software. Nothing here is financial advice, and this case study makes no claim about trading results.

Most people learn to trade by risking money before they have a process. Vector Games takes the opposite approach: learn the rules in short lessons, practise them on simulated prices, record every trade, and earn rank for discipline rather than for profit.

That brief needs a real trading workspace, not a toy chart, and it needs a school and a game around it. It also needs a strong privacy line. A trader's positions, balances and journal are private, including from the people who run the platform.

The system

Vector Games reuses work we had already proven. The membership, course and gamification layers come from the KinglyVault platform. The trading core comes from our earlier Trade OS work, carried over with its tests. We built the school content, the game layer and the new terminal features on top.

Members use a web app hosted on Netlify. It talks to an always-on server on Fly.io, because simulated trading and price data need a program that never stops. One database holds everything in two walled sections: one for platform data and one for each member's private trading data. Clerk handles identity and Whop handles the Pro membership.

Outcomes

The public site is live, and it lists 10 Academy units, 51 played lessons, 9 mini-game types, 7 rank tiers and 23 paper markets.
66 database tables across 18 trading files, counted from the repository.
46 server test files and 86 frontend and core test files, counted from the repository.

We make no performance, profit or return claims for Vector Games, and we hold no such figures.

Step by step

How Vector Games works, step by step

This follows a member from a lesson to a recorded practice trade. By default, every price here comes from a labelled simulated feed.

Learn a rule
What happens
The member plays short Academy lessons, built as a game with levels and boss rounds. A review queue brings older topics back.
Who or what does it
The member, in the Academy.
Why it matters
They meet the idea, such as position sizing, before they use it.
Practise in a mini-game
What happens
Daily challenges and mini-games drill one skill. The server sets each game's starting seed, stores it, and replays the game from the member's actions to work out the score.
Who or what does it
The member plays. The server checks.
Why it matters
A score cannot be faked from the browser, so ranks mean something.
Place a practice order
What happens
On the paper desk, the member uses charts and an order ticket for market, limit or stop orders, with stop-loss and take-profit levels.
Who or what does it
The member, at the trading desk.
Why it matters
They use a real workspace with no real money at risk.
The system confirms it is theirs
What happens
The server checks who the member is. Every trading request and database query is limited to that signed-in person.
Who or what does it
The server's trading router.
Why it matters
One member can never see another member's positions or journal.
Risk rules speak up
What happens
If an order breaks a rule, the risk rules engine shows it next to the order and records it in the journal.
Who or what does it
The risk rules engine.
Why it matters
Mistakes surface while the member is making them, which is when a habit can change.
A simulated fill
What happens
The paper engine fills the order against simulated bid and ask prices, then handles stops and targets.
Who or what does it
The paper engine on the server.
Why it matters
Practice behaves like a real order but cannot lose real money.
Review and earn rank
What happens
Each closed trade lands in the journal for tags, grades and emotions. XP rewards process rather than profit, and an AI coach explains concepts but refuses to make trade calls.
Who or what does it
The member, with the journal and coach.
Why it matters
People are rewarded for following the plan, not for a lucky win.
A privacy wall protects the data
What happens
A guard stands in front of every generic data route, for all callers including admins. It rejects anything that touches trading data.
Who or what does it
The server's privacy guard.
Why it matters
A trader's positions, balances and journal stay private, even from the people who run the platform.

Architecture

How the system fits together

01 / 06 What the member uses

Web appDesk, Academy and Arena on Netlify.→ Clerk · sign-in → Node API · session token

02 / 06 Sign-in

ClerkHandles secure sign-in.

03 / 06 The server

Node APIAlways-on server, because simulated trading never pauses.→ Privacy guard · platform data → Trading router · orders
Trading routerLimits every query to the signed-in member.→ Paper engine
Paper engineFills orders at simulated prices, with stops and targets.→ Postgres trading schema
Market dataA labelled simulated price feed by default.→ Paper engine · prices

04 / 06 Privacy wall

Privacy guardBlocks generic data routes from trading data.→ Postgres public schema

05 / 06 Stored records

Postgres public schemaCourses, XP and memberships.
Postgres trading schemaEach member's private trades and journal.

06 / 06 Billing

WhopHandles Pro membership through signed messages.→ Node API · signed webhook

Seven rank tiers. XP rewards process, not profit.

Key features

Trading desk

Paper desk with charts, watchlist and order ticket: market, limit and stop orders with stop-loss and take-profit
Risk-based position sizing, plus calculators for compounding, lot size, risk of ruin, reward-to-risk and pip value
Chart Grid with several live charts, per-tile symbol and timeframe, and saved layouts
Advanced Terminal: multi-chart layouts, about 85 studies with no per-chart limit, drawing tools, volume profile, Heikin Ashi, Renko and range charts, and bar replay with a practice book. It integrates the MIT-licensed Quant Terminal project, and in this workspace orders are paper only

Research and testing

Strategy Lab with 15 strategies and a backtester, plus walk-forward, overfitting and cost-stress checks
Eight-vote scanner that combines several signals, with export to TradingView's Pine language
No-code indicator builder with 7 patterns
Signal rules evaluated at bar close, economic calendar and intel feed

Journal and school

Journal with tags, grades, emotions, a calendar, habit statistics and PDF or CSV export
Academy with 10 units and 51 played lessons, built as a game with levels, boss rounds and a spaced review queue
Risk rules engine that shows a broken rule next to the order and records it in the journal
AI coach that is rule-based by default, explains concepts and refuses to make trade calls

Arena and arcade

9 mini-game types and 7 rank tiers, with XP awarded for process rather than profit
Daily challenge and weekly tournament with leaderboards that show only a display name and score
Opt-in paper competitions

Delivery

The current repository starts on 20 October 2026, when we combined the two existing platforms into a single codebase. It holds 372 commits across branches through 28 October 2026. Work ran in focused branches (order entry, indicators, position accuracy, seconds charts, history depth), each with its own written document and test evidence.

Indicator accuracy is a good example of the process. For the classic studies we read values out of TradingView's built-in indicators on a shared data feed, then compared them to ours point by point and recorded the error in a parity table in the repository.

Security & infrastructure

Admin privacy boundary. A server guard sits outside every generic data route, for all callers including admins. It rejects anything that touches trading data. The blocked list is read from the trading database file, so new tables are covered automatically. Tests use two users and an admin against a real database.
Per-user limits. Every trading route requires sign-in, and every database query is limited to the signed-in user. No admin path exists.
Tamper-resistant games. The server issues every game seed, stores it, and re-runs the game from the seed and action log. It never reads a score from the client.
Scoped agent access. Device tokens are hashed, rotating and revocable, and money-moving routes cannot be reached with them.
Paper by default. New members trade simulated money. Linking an external broker account is a separate path with sealed credentials, a per-account opt-in that defaults to off, a server-side plan check, an audit trail and an operator kill switch.
Billing. Membership runs through signed Whop webhooks, and access is checked on the server.

What's next or limits

Most of the product sits behind sign-in, so the images here show the public site only. Some features depend on operator settings or on a member's own key. These include live research sources, the AI journal read and Telegram delivery. Default prices come from a labelled simulated feed.

Built with

The tools behind it

For technical readers, here is what it runs on. Tap a name to highlight it. The words explained below appear across this page.

What these words mean

Paper trading: Practising trades with simulated money.
Bid and ask: The prices buyers will pay and sellers will accept.
Stop-loss and take-profit: Preset prices that close a trade to limit a loss or lock in a gain.
Backtest: Testing a strategy on past prices.
XP: Experience points that show progress in the game.
Repository: The stored, versioned code of a project.
Schema: A separate section of a database, used here to wall off private data.
Webhook: An automatic message from one service to another.