01 · AI market intelligence
Apex
Apex combines my market-analysis algorithms with an LLM that explains the results.
I turned several years of market research and TradingView experiments into Python algorithms, then used an LLM to explain their output in plain language. The product is live and paid.
Why this product exists
Context
Traders can access endless indicators and opinions, but more input often creates less conviction. Generic chatbots can explain a chart, yet they lack the domain pipeline, live context, and deterministic checks needed for a repeatable market product.
Product problem
The product had to reduce analytical overload and emotional decision-making while keeping inference cost low enough for a credit-based business. It also had to explain uncertainty without presenting probabilistic output as financial certainty.
Who it serves
Active traders, market analysts, and beginners who need a clearer second opinion before acting.
What good looked like
A useful analysis helps a user understand the setup, risk, and counter-case in time to make a considered decision.
What made it difficult
Cost
A premium model making every analytical decision made the unit economics fragile.
Control
Raw-data prompting made output harder to reproduce, test, and guard against fabricated claims.
Time
Users needed a decisive read in seconds, not a research report that arrived after the moment passed.
Responsibility
The product had to support decisions without promising returns or hiding uncertainty.
What I built first, and why
- 1Shipped
Build the analytical core
I converted years of Pine Script experiments and market logic into Python services that could process normalized live data.
- 2Live
Structured analytical input
The pipeline calculates signals, regimes, levels, conflicts, and risk first. The LLM receives evidence, not an open-ended chart-reading task.
- 3Live
Analysis output structure
Outputs lead with a verdict, confidence, why-now context, key levels, invalidation, and the strongest counter-case.
- 4Live
Payment and retention
I introduced prepaid credits, a free trial, simplified analysis modes, daily grants, and targeted win-back communication.
The calls I had to make
Separate computation from explanation
This moved expensive reasoning out of the language layer, reduced cost by roughly 95%, and made failures easier to trace.
Reduce configuration to two modes
The analysis builder was simplified to Standard and Forecast. Complexity still exists in the engine, but no longer becomes the user's burden.
Limit LLM usage
Always-on market content uses deterministic language generation; deeper paid analyses use the LLM. This removed about 80 redundant daily calls.
Support users during an open trade
The Panic Button reframes an open position through risk, invalidation, and evidence when a user is most likely to act impulsively.
How the system works
Acquire
Market, macro, and event data from multiple APIs and exchanges.
Normalize
Asset-aware timeframes, validation, caching, and source fallbacks.
Compute
Python algorithms calculate signals, levels, regimes, conflicts, and risk.
Explain
A cost-optimized LLM turns structured evidence into a consistent decision format.
Deliver
Celery and Redis run non-blocking jobs; React presents the result and credit usage.
What I personally owned
- Product thesis, positioning, roadmap, pricing, and launch
- Complete product UX, analysis flow, output hierarchy, and design system
- Market algorithms, Python services, prompt architecture, and guardrails
- React and TypeScript frontend, APIs, infrastructure, billing, and production operations
- Instrumentation, retention experiments, incident fixes, and ongoing iteration
What you can inspect
Working customer journey
Account creation, credit purchase, analysis configuration, queued processing, structured result, and history are in production.
Product decisions connected to implementation
The codebase contains the analysis engine, provider-aware AI service, usage logging, pricing, retention tasks, and explicit TODOs when a promise is not yet true.
Production infrastructure
FastAPI, PostgreSQL, Celery, Redis, Docker, Nginx, and Cloudflare support live delivery and paid usage.
Inside the product
Where it stands today
Apex is live and monetized. Moving computation into deterministic services reduced LLM cost by roughly 95% and made the analytical pipeline easier to test and operate.
What I learned
- 01
An LLM becomes more useful when the product gives it less ambiguity.
- 02
Unit economics is a product design constraint, not a backend cleanup task.
- 03
Advanced products can keep a sophisticated engine while offering a simple decision surface.