Trade Compass
Master Forex Trading with Interactive Learning — learning models, games, UI/UX & trading simulations
Scorecard
| Dimension | P0 | P1 | P2 | P3 |
|---|---|---|---|---|
| Architecture | 0 | 1 | 1 | 0 |
| Code Review | 1 | 2 | 2 | 2 |
| Design | 0 | 1 | 1 | 1 |
| Integrity | 1 | 2 | 1 | 1 |
| Production | 1 | 2 | 2 | 1 |
| Dependencies | 0 | 0 | 1 | 0 |
| Tests | 0 | 1 | 1 | 0 |
| Docs | 0 | 1 | 1 | 0 |
| Mobile | 0 | 1 | 1 | 1 |
Remediation Status 10/15 fixed
Every finding below was cross-checked against the live codebase. "Fixed" items are baked into the verified dist/ build; "Deferred/pending" items need either a backend you must restore or a larger refactor.
| ID | Finding | Status | Evidence / Note |
|---|---|---|---|
| P0-1 | Supabase Cloud backend dead | PENDING (backend) | Cannot be fixed in code — VITE_SUPABASE_URL must point to a live project. Offline mirror (P0-3) makes the app work regardless. |
| P0-2 | PatternDragDrop unplayable on mobile | FIXED | Reworked to tap-to-select→tap-to-place + keyboard; drag kept for desktop. PatternDragDrop.tsx. |
| P0-3 | No offline progress fallback | FIXED | New lib/offline-store.ts (localStorage write-behind, never loses mastery) integrated into use-progress.ts. |
| P1-1 | No shared offline banner | FIXED | OfflineBanner + use-backend-status rendered globally in Layout.tsx. |
| P1-2 | MarketAnalysis/PriceChart monoliths | DEFERRED | 2,137-line refactor risk > benefit this pass; noted for a dedicated refactor. Contains the new chart skeleton already. |
| P1-3 | Hardcoded/inaccurate pip values | FIXED | PipValue/PositionSize calculators now use computed getUsdPipValuePerLot + "approximation" note for cross pairs. |
| P1-4 | 4-vs-5 decimal inconsistency | FIXED | getPriceDecimals now reads the pair catalog (5 majors, 3 JPY, 2 metals). |
| P1-5 | No CI/CD, deploy, monitoring | PENDING | Recommended a GitHub Actions workflow; requires Hostinger SSH/SFTP creds to wire deploy. |
| P1-6 | Synthetic data mistaken for live | HANDLED | Verified getTechnicalSignals already fails closed on synthetic + DataQualityBadge flags it. Not over-engineered. |
| P1-7 | Weak auth / no password policy | FIXED (client) | Client-side ≥8-char password validation + minLength=8. Server side (Supabase rate limits) still recommended in-project. |
| D2 | Touch-first game interaction | FIXED | PatternDragDrop tap-to-place (also improves pip/quiz games cursor sizing). |
| D5 | Quizzes use computed pip values | VERIFIED SAFE | PipValueQuiz questions already teach correct formulas (verified USD/JPY ≈$6.50, CHF ≈$10.30). Display tools now computed. |
| D10 | Add tests for mastery/SM-2/sizing | FIXED | New src/test/remediation.test.ts (10 tests): mastery gate, offline store, SM-2 score, position sizing. 67/67 total. |
| Deepen quizzes | Too few questions on high-stakes lessons | FIXED | Position Sizing 2→5, Risk-Reward 3→6, Lots/Leverage/Margin 4→7 (applied math + fill-in-blank + genuine ordering). |
| P3 / PWA | No manifest / OG image / skeleton | FIXED | manifest.webmanifest, mobile-web-app meta, OG image meta, market-chart loading skeleton. |
Verification Gate (all GREEN)
npm run build— clean (12s)npx tsc --noEmit— cleannpx vitest run— 67/67 pass (57 previous + 10 new remediation tests)- Fixes confirmed present in built
dist/assets (mastery-gate string, offline-store key, manifest)
Deployment: The verified build is at /workspace/trade-compass/dist/, ready to push. Publishing to the live Hostinger site requires your Hostinger SSH/SFTP credentials (not available in this environment) — I could not and will not fabricate a deployment.
P0 — Critical
Configured Supabase Cloud backend is dead — almost every persistent feature is broken
Impact: The live build points at the Supabase Cloud project avhyrrrmlclnynhddrtp.supabase.co, which returns HTTP 000 / no DNS. This kills the entire personalized layer: auth/login, signing up, lesson & module completion, XP, badges, SM-2 flashcard scheduling, journal persistence, skill tree, community posts, leaderboard, generated lessons, and admin content. The app silently degrades into a read-only "public curriculum" and only the market data page (TwelveData/Yahoo) keeps working.
Fix: Decide the real backend. Either (a) restore/point to a LIVE Supabase project and set VITE_SUPABASE_URL + VITE_SUPABASE_ANON_KEY (and run all migrations/RPCs/RLS), or (b) if no backend is intended, build a proper offline-first persistence layer so progress is never lost. Verify curl https://<project>.supabase.co/auth/v1/health = 200 before shipping.
PatternDragDrop game is unplayable on mobile — no touch handlers
Impact: This game relies purely on HTML5 drag-and-drop (draggable, onDragStart, onDrop), which does not fire on touch devices. On the phone/tablet the user wants to learn on, the draggable chips cannot be dragged, so the game is effectively unplayable — a hard break of the "match candlestick patterns" learning goal on mobile.
Fix: Add a touch-compatible interaction — either a tap-to-select + tap-to-place flow, or Pointer Events with drag thresholds. Simplest robust fix: swap the chip drag for a "tap pattern name, then tap the chart" two-tap interaction that works identically on mouse and touch.
No local/offline fallback for progress — SM-2 reviews, XP & completions are lost when Supabase is down
Impact: Because the entire write path is Supabase-only with no localStorage mirror, the learning model (spaced-repetition review schedule, module mastery, badges, XP) has zero resilience. When the backend is down — which is today's reality — a learner's hard-earned progress simply does not persist, and SM-2 "due date" scheduling silently resets. This defeats the core purpose of a learning platform.
Fix: Add an offline queue: write progress to localStorage first, then best-effort sync to Supabase when reachable (write-behind with a sync marker, like the existing shouldBypassSupabase pattern but mirrored to disk). On reconnect, flush queued writes so nothing is permanently lost.
P1 — High
Live-app experience is misleading without a shared offline banner
Impact: Market data is genuinely live while personal data silently fails. A user sees working charts/prices but their login, journal, and progress don't persist — without a shared banner it reads as "the app is buggy," not "backend offline." Learners will waste clicks retrying features that can never work.
Fix: Add a global, dismissible "Offline — progress syncing disabled" toast/banner (via the TopNav DataQualityBadge area) whenever Supabase is unreachable, and consider a read-only lock on progress-gated actions.
A blind-flagship market pages are monoliths — MarketAnalysis is 2,137 lines
Impact: Three files each exceed 1,600 lines. Despite some sub-component extraction in components/market/*, the orchestration surface is still huge, slowing review, testing, and adding merge-conflict risk for the areas the user wants to improve (sims, UI/UX).
Fix: Extract the market rail (screener), the analysis tabs, and the chart wrapper into focused components/hooks; move hardcoded synthetic fallback arrays into a data module.
Static FX metadata uses hardcoded pip values that are inaccurate for non-USD-quote pairs
Impact: The static pipValuePerStd table is used for display metadata in places and contradicts the computed function getUsdPipValuePerLot. Values like USD/MXN 0.1 are wrong (1 standard lot USD/MXN is worth far more than $0.10). Learners could be shown inaccurate per-lot values on the pip-value calculator and pip quiz.
Fix: Make the calculators and PipValueQuiz always use getUsdPipValuePerLot (computed with live/conversion price) and drop the hardcoded pipValuePerStd for display, or mark it clearly as "approximate at current rate."
Decimal formatting is inconsistent (4 vs 5 decimals) between getPriceDecimals and FX_PAIR_INFO
Impact: getPriceDecimals returns 4 decimals for EUR/USD (prices like 1.0835) while the pair catalog declares 5. Real institutional/pip-precision FX quotes majors at 5 decimals (1.08352). Displayed prices and chart axis precision are inconsistent across tools.
Fix: Align getPriceDecimals to 5 for standard 5-decimal majors (non-JPY, non-exotic) so quotes match the pair catalog and pip math presentation.
No CI/CD, no automated deployment to Hostinger, no monitoring/health checks
Impact: The build is a manual npm run build + push to Hostinger. There's no pipeline to test-and-deploy, no way to know when Supabase or the /api proxies go down, and no rollback safety. This is how the dead backend went unnoticed.
Fix: Add a GitHub Actions workflow (lint → tsc → vitest → build → deploy to Hostinger via SSH/FTP), plus a simple uptime/health check (HTTP 200 + supabase reachable) alerting on Telegram/email.
Synthetic candle fallback is honest but can be mistaken for live data at a glance
Impact: When live data fails, the app renders seeded-random-walk candles. The DataQualityBadge exists in TopNav, but the charts themselves don't visually suppress drawing tools/analysis, so a learner could practice drawing on fabricated data believing it's the real market. The badge alone may not be enough emphasis on the analysis page.
Fix: When quality==="synthetic", add an inline crimson "SIMULATION / not live" overlay on the chart card plus gate the Trade Planner from producing signals on fake data, keeping the honest note.
Auth/integrity has no rate limiting and no password-strength policy (Supabase-side hardening not evident)
Impact: The app relies on Supabase Auth defaults for brute-force protection. With the backend currently down this is latent, but once restored, login/signup will be exposed to brute-force and abusive signups if rate limiting and email-confirmation-to-login are not enforced.
Fix: In the Supabase project, enforce rate limiting on auth (Supabase has built-in auth/rate_limits), require email confirmation, and add a min-password-length validator on the client.
P2 — Medium
| ID | Finding | Location | Effort |
|---|---|---|---|
| P2-1 | 47 ESLint errors (all no-explicit-any) and 24 warnings leave the codebase type-leaky in key spots | src/** + supabase/functions/* | Medium |
| P2-2 | No Supabase RLS/migration runbook checked in for the tables the app writes to (lesson_progress, game_scores, profiles, flashcard_progress, journal, community) | (no supabase/migrations committed) | Medium |
| P2-3 | Market data API keys/env handled only via Hostinger server side; no clear docs on how /api/twelve + /api/calendar are wired on the shared host | netlify.toml vs live Hostinger /api behavior | Medium |
| P2-4 | No empty-state strategy: Community, Leaderboard, Journal show raw/blank states instead of guided "start here" experiences | src/pages/Community.tsx, Leaderboard.tsx, Journal.tsx | Medium |
| P2-5 | No loading skeletons on slow market pages; users see blank chart area while TwelveData loads | src/components/market/MarketChartArea.tsx | Low |
| P2-6 | Accessibility gaps: mixed nav semantics, some low-contrast muted text, drag-only interactions, no focus-visible theming pass | src/ (TopNav, GameShell, MarketAnalysis) | Medium |
| P2-7 | No structured logging/observability on the client; silent .catch(() => {}) on several supabase writes can hide failures | src/hooks/use-*.ts (network writes) | Medium |
| P2-8 | Supabase schema types in src/integrations/supabase/types.ts (997 lines) may be stale vs the actual DB; several writes use as any casts | src/integrations/supabase/types.ts | Low |
| P2-9 | Simulations.ts scenarios (Learning the System, Finding Your Edge) are educational but not wired to the live chart/market context; feels disconnected | src/data/simulations.ts | Medium |
| P2-10 | Leaderboard and community depend on hooks with 13-16 supabase refs; when backend restores, no seeded/admin content exists to make them feel alive | src/hooks/use-community.ts, use-journal.ts | Medium |
P3 — Low / Polish
| ID | Finding | Location | Effort |
|---|---|---|---|
| P3-1 | fetchPipValue / PipValueCalculator shows hardcoded-ish defaults; should always compute live at current rate | src/pages/PipValueCalculator.tsx | Low |
| P3-2 | SwapCalculator is a separate tool with no live swap-rate source — will show stale/static values | src/pages/SwapCalculator.tsx | Low |
| P3-3 | No global keyboard shortcuts / command palette focus (CommandPalette exists but is not wired into a discoverable trigger) | src/components/CommandPalette.tsx | Low |
| P3-4 | Trade plan/setup notes (MarketSetupTab) persist only to local component state when backend is down — no sync indicator | src/components/market/MarketSetupTab.tsx | Low |
| P3-5 | Learning path lock state hardcodes lockedReason: undefined as "placeholder for now" — real gating depends on Supabase skill tree | src/pages/LearningPath.tsx:84 | Low |
| P3-6 | Meta/OG image + PWA manifest could be added for shareability and install-to-homescreen on mobile | index.html | Low |
Quick Wins
Architecture 7/10
Trade Compass is a Vite + React 18 SPA with shadcn/ui design system, TanStack Query data layer, and Supabase as its persistence/auth backend. It is a single frontend with no separate API server — data comes from Supabase (users/progress/journal/community), and market data is proxied through the Hostinger host's /api/* handlers to TwelveData (live), Yahoo Finance (delayed), and ForexFactory (economic calendar). The app ships ~43K lines of source across 36 pages, 10 games, ~30 hooks, and a rich component tree.
Stack
- Frontend: React 18.3, Vite 5, TypeScript 5, Tailwind 3.4, shadcn/ui + Radix primitives
- Data: @supabase/supabase-js, @tanstack/react-query, lightweight-charts + recharts
- Motion: framer-motion, embla-carousel
- Backend stores: Supabase Cloud (users, progress, journal, community, admin content) — currently unreachable
- Market data: TwelveData (live) / Yahoo (delayed) / ForexFactory (calendar) via Hostinger /api proxies
- Deployment: Hostinger shared hosting (static dist/ + /api/ server handlers)
Data Model
profiles → lesson_progress, lesson_completions, module_completions, game_scores, user_badges, flashcard_progress (SM-2), story_progress, generated_lessons, user_skill_scores, skill_prerequisites, journal trades, community posts. The architecture is clean and idiomatic; the sole structural weakness is the reliance on a single external backend with no local resilience.
Code Review 6/10
TypeScript compiles cleanly (npx tsc --noEmit passes) and npm run build succeeds in 14s. The trade math (trade-math.ts position sizing, R:R; trading.ts pip/contract values; use-flashcard-sm2.ts SM-2) is correct and well-tested — 56 indicator tests plus a growth suite give real confidence in the domain logic. The candlestick SVG pattern rendering was reviewed and verified coordinate-consistent (a smell I chased turned out correct). Weaknesses: 47 no-explicit-any lint errors, several multi-thousand-line components, and silent error swallowing on supabase writes.
Design 7/10
The UI is a polished dark "trading desk" theme: near-black background, refined indigo accent (#18253a / #6c6cf0 family), Inter typography with tight tracking, serif display headers on hero/game results, monospace price reads, subtle card shadows, and a real dark/light toggle via next-themes. Animations (framer-motion staggering, chart glow, game shell transitions) are tasteful and on-brand. Honest data-quality signaling (DataQualityBadge for live/delayed/synthetic).
UI/UX Recommendations
- Make every game touch-first: PatternDragDrop needs a tap-to-select → tap-to-place flow (P0).
- Add loading skeletons to the market chart area and guided empty states to Community/Journal/Leaderboard.
- Add a discoverable Command Palette trigger (currently not wired to any keyboard shortcut/menu).
- Sweep low-contrast
text-muted-foreground/50usages and add a focus-visible theming pass for WCAG AA. - Show a persistent "PROGRESS SAVED / OFFLINE" indicator next to the user avatar so persistence failures are never silent.
Integrity 3/10
The dominant integrity issue is backend availability: the configured Supabase project's DNS does not resolve, so every persistent capability is unreachable. There is sound defensive engineering elsewhere — honest market-data quality flags (live/delayed/synthetic), correct position/pip math, parameterized supabase writes, and the app degrades gracefully (read-only curriculum still works). But the write path is Supabase-only with no mirrored fallback, so integrity of user data is not preserved during an outage — the exact failure happening now. No client-side logging aggregates these failures either.
Production 4/10
The live Hostinger site returns HTTP 200 and the /api/twelve (TwelveData) and /api/calendar (ForexFactory) proxies are actually functional — I verified real market + calendar data flowing. That's a strong positive. The production gap is operational: no CI/CD, no automated deployment, no health check, no monitoring/alerting, no versioned rollback, and no deployment runbook. The dead Supabase backend is a production outage that nothing noticed until now. Build reproducibility is good (clean build in 14s), but delivering quality requires adding the ops wrapper.
Dependencies 8/10
Dependencies are modern and appropriate for the domain: React 18.3 + Vite 5 + TypeScript 5, shadcn/ui (Radix primitives), TanStack Query 5, lightweight-charts (real candlestick/trading charting), recharts, framer-motion, zod, react-hook-form, embla-carousel, sonner, vaul. No deprecated packages observed; the stack is well-sized for a trading-education SPA. Two watch items: next-themes is tuned for Next.js (the app built a custom useTheme elsewhere), and the Supabase Edge Function deps are only relevant if/when the backend is restored.
Tests 7/10
npx vitest run → 57/57 pass, dominated by 56 indicator tests in src/test/indicators.test.ts that genuinely verify technical-indicator math (RSI, MACD, Bollinger, etc.). This is a real, valuable suite. The gap is breadth: almost no component tests for the games (SM-2, quiz grading, position-sizing UI), no API/hook integration tests, and no E2E. Because the user's stated goals are the learning models, games, UI/UX, and trading simulations, those are exactly where targeted component/integration tests would lock in correctness and prevent regressions.
Docs 5/10
A README.md and LOGIN_DETAILS.md document the stack and local Supabase dev setup, and the code is well-commented. Missing: a Hostinger-specific deployment runbook (how /api/* proxies are wired on the shared host, how to rebuild + push, how to set the Supabase env), no API/data documentation, and no committed Supabase schema/migration/RPC/RLS runbook. Given the live deployment's complexity (proxies + env + backend), a runbook is the highest-value doc investment.
API Surface
The app's client-side API surface is: Supabase tables/RPCs (auth + persistence) and three proxied market-data endpoints. All frontend fetch calls match the Hostinger /api/* proxy routes, which are verified live. When Supabase is restored, the tables below become write targets.
| Type | Endpoint / Table | Status | Purpose |
|---|---|---|---|
| Market | GET /api/twelve/time_series | ✅ LIVE | Live FX candles (TwelveData) |
| Market | GET /api/twelve/api_usage | ✅ LIVE | TwelveData credit usage |
| Market | GET /api/yahoo/v8/finance/chart/… | ✅ LIVE | Delayed candles (Yahoo) |
| Calendar | GET /api/calendar/ff_calendar_*.json | ✅ LIVE | Economic calendar (ForexFactory) |
| Auth | supabase.auth.signInWithPassword / signUp | ❌ DOWN | Login / register |
| Auth | supabase.rpc("has_role", {_role}) | ❌ DOWN | Admin gate |
| Data | supabase.from("lesson_progress"|"module_completions"|…) | ❌ DOWN | Progress / mastery / XP / badges |
| Data | supabase.from("flashcard_progress") | ❌ DOWN | SM-2 spaced-repetition state |
| Data | supabase.from("journal" trades) / use-community posts | ❌ DOWN | Journaling + community |
Mobile 5/10
The viewport meta and theme-color are present (installable-feel foundation), and most games use tap-friendly buttons and the shared GameShell. The killer mobile gap is PatternDragDrop using HTML5 drag-and-drop with no touch handlers (P0-2) — unplayable on phones. The pip/position-size calculators and market screeners are responsive enough, but there's no mobile-specific testing framework and some text-[9px]-level sizing inside the drag-drop cards is too small. Trade Planner + chart drawing also lean mouse-first. A dedicated mobile pass (touch calibration, 44px targets, chart pinch/pan) is needed, alongside a Playwright mobile smoke test to keep it honest.
Roadmap
2-Week Sprint Plan
- D1Restore/point to a LIVE Supabase project; verify /auth/v1/health = 200 and write migrations/RPCs/RLS — P0-1
- D2Rework PatternDragDrop to tap-to-select → tap-to-place (touch-first) — P0-2
- D3Add localStorage write-behind mirror so progress/SM-2/journal survive outages — P0-3
- D4Add global offline banner + per-widget "PROGRESS SAVED" indicator — P1-1
- D5Make pip calculators + PipValueQuiz always use computed perpendicular values; drop hardcoded pipValuePerStd display — P1-3
- D6Align getPriceDecimals to 5 decimals for FX majors — P1-4
- D7Add synthetic-data overlay + lock Trade Planner when quality===synthetic — P1-6
- D8Extract MarketAnalysis/PriceChart monoliths into focused components + hooks — P1-2 / P2
- D9Add GitHub Actions CI (lint → tsc → vitest → build) + Hostinger deploy target — P1-5
- D10Cleanse 47 no-explicit-any lint errors; add game/component tests for SM-2 + quiz + position sizing — P2
6-Month Vision
| Phase | Focus |
|---|---|
| Q1 | Backend restore + offline-first resilience, touch-first games, decimal/pip correctness sweep, CI/CD + Hostinger deploy pipeline, monitoring/health checks |
| Q2 | Deepen the learning model: mastery-based module gating, adaptive spaced-repetition dashboards, guided "skill tree" progression, per-game analytics for difficulty tuning |
| Q3 | Premium trading simulations: scenario library wired to real market context, trade-replay with branching outcomes, risk-management sandbox with portfolio-level feedback |
| Q4 | Community & growth layer: live leaderboards, public sharing of setups, cohort challenges, mobile PWA install, comprehensive UX/a11y pass |
Backlog
| Epic | Stories | Story Points |
|---|---|---|
| Backend & resilience | Restore live Supabase, migrations/RPCs/RLS runbook, localStorage write-behind mirror, offline banner+progress indicator, client logging | 13 |
| Learning models | Touch-first game interactions, SM-2 + quiz + position-sizing component tests, mastery gating, spaced-repetition dashboard | 11 |
| Trading simulations & math | Computed pip values everywhere, decimal alignment, live-context simulation library, trade-replay branching, synthetic-data lock | 12 |
| UI/UX & mobile | Command palette trigger, skeletons, guided empty states, focus-visible/a11y pass, PWA+OG meta, mobile chart pinch/pan | 14 |
| DevOps & docs | GitHub Actions CI, Hostinger deploy target, health checks/alerting, deployment runbook, API data docs | 9 |
| Total | 29 stories | 59 SP |
Pro-Grade Learning Path 5/5 built
Expanded the curriculum from a 15.7-hour foundation into a professional-grade path that confirms understanding, forces retention, requires judgement, tiers depth, and ends in a prop-firm-style evaluation. Everything below is implemented in source and shipped in the verified dist/ build (build clean · tsc clean · 71/71 tests).
| # | Recommendation | Implementation | Status |
|---|---|---|---|
| 1 | Confirmation Battery — confirm applied skill, not just recall | New ApplicationCheck (graded compute/scenario), OpenResponseCheck (self-assessment w/ rubric), SkipCriteriaDrill (judgement) section types wired into the renderer. 6 confirmation checks added to high-value lessons (Position Sizing, Risk-Reward, Pip's, Engulfing). Mastery gate (≥80%) already enforces progression. | BUILT |
| 2 | Retention forcing — stop knowledge decay | Offline SM-2 spaced-repetition store (lib/offline-store.ts) + RetentionDeck auto-seeded on every lesson from quiz Q&As; DueReviews summary+list on the Learning Hub. Works with no backend. | BUILT |
| 3 | Deepened quizzes — more application, more questions | Position Sizing 2→5, Risk-Reward 3→6, Lots/Leverage/Margin 4→7 (applied math + fill-in-blank + genuine ordering). | BUILT |
| 4 | Three-stage tiering — Foundation→Applied→Mastery | All 9 modules assigned a tier. Applied/Mastery modules show a "Locked: Master the prior tier first" banner (offline-computed) until the preceding tier is mastered at ≥80%. | BUILT |
| 5 | Graded Simulated-Prop Trial — the pro-acceptance test | New /prop-trial page: $50k sim account, 1% risk, log 25 setups, survive 7% max drawdown, hit +10R → "Prop-Funded Trader" certificate. Offline ledger. CTA from Career Mode. | BUILT |
Verification
npm run build— clean (11s)npx tsc --noEmit— cleannpx vitest run— 71/71 pass (added offline SM-2 retention tests)- All new features confirmed present in built
dist/assets/*.js
Deployment: The verified build is at /workspace/trade-compass/dist/, ready to push to Hostinger (requires your Hostinger SSH/SFTP credentials).
Recommendations
Offline-first progress (localStorage mirror + sync)
Learners never lose XP, completions, or flashcard schedules. Largest reliability win; directly enables the app to work even when the backend is down.
Touch-first game interactions on every game
Rework PatternDragDrop to tap-to-place and calibrate all games for 44px touch targets — the platform is mobile-first for the target learner.
Live-context simulation engine
Wire the trading sims + trade-replay to the real market so scenario practice feeds off TwelveData context and switching to "SIMULATION" is explicit — a true practice-vs-live training loop.
Mastery-based learning path with spaced-repetition dashboard
Surface SM-2 due reviews, module mastery bars, and a skill-tree progress map so learners see a guided, adaptive path instead of a flat module list.
CI/CD + uptime & backend health alerts
Automated lint→tsc→test→build→deploy plus a health check that alerts when Supabase or /api proxies go down — prevents the current silent-outage class.
Community cohort & portfolio analytics
When the backend returns, add cohort challenges, public setup sharing, and per-learner analytics to drive engagement and retention.
Priority-ranked forward-looking ideas (user focus: learning models · games · UI/UX · trading sims)
| # | Idea | Area | Impact | Effort |
|---|---|---|---|---|
| 1 | Adaptive difficulty + streak psychology on every game (right-sized per-learner, not just per-accuracy) | Games / Learning | High — keeps learners in flow | M |
| 2 | Trade-replay sandbox: replay any journal or simulated trade with branching "what if" sliders (stop/target/winsize) and a final P&L + risk recap | Trading sims | High — turns theory into mastery | M |
| 3 | Live "Market Conditions" practice mode — quiz learners on the actual overnight news/levels from the economic calendar before a simulated session | Trading sims / UX | Medium | M |
| 4 | Command palette wired to ⌘K with deep-links to every module, game, and tool | UI/UX | Medium — power-user speed | S |
| 5 | Focus-visible + full keyboard/AA accessibility pass on games and market pages | UI/UX | Medium — reach + polish | M |
| 6 | PWA install + offline learning (static lessons readable offline) | UI/UX | Medium | M |