01 The Platform
For years I've been fascinated by the idea that markets move in fractal waves and repeating cycles rather than random noise. SharpTechnicals is my long-running attempt to turn that intuition into something measurable. It ingests market price data, enriches every bar with a dense set of analytical features — fractal events, support/resistance levels, technical indicators, cycle data — and exposes the results through a web UI and a set of offline machine-learning experiments.
Unlike a quick POC, this one grew into a proper multi-project solution — 28 projects with a real layered architecture, a production data store, background sync jobs, and pluggable data feeds. It was recently modernized from .NET Framework 4.8 to .NET 8 LTS without rewriting the core.
The stack:
- Core — C# / .NET 8 (migrated from Framework 4.8)
- Data store — MongoDB, behind a generic repository
- Web UI — ASP.NET Core MVC with HighCharts OHLC rendering
- Background sync — a .NET Generic Host Windows Service
- Feeds — Tiingo, Yahoo Finance, Quandl, Financial Modeling Prep, CSI Data
- ML — GeneticSharp (strategy evolution), Accord.NET (decision trees / random forest)
- Desktop charting — WPF + SciChart
02 A Layered Architecture
The solution is strictly layered. Everything depends on a shared Entities project; interfaces are defined once and implemented by swappable storage and connector projects. That's what keeps a feed (Tiingo vs. Yahoo) or a store (MongoDB vs. CSV) interchangeable — and it's what let me migrate the whole solution to .NET 8 without touching the analytics engine.
┌──────────────────────────────────────────────────┐
│ SharpTechnicals.Entities │
│ domain models · enums · interfaces │
└──────────────────────────────────────────────────┘
▲ (everything depends on this)
┌──────────────────────────────────────────────────┐
│ Pattern (interfaces) · Utilities │
└──────────────────────────────────────────────────┘
▲
┌──────────────────────────────────────────────────┐
│ Features (analytics) ──► Markets │
└──────────────────────────────────────────────────┘
▲ ▲
┌─────────┴──────────┐ ┌────────────┴──────────┐
│ Storage │ │ Connectors │
│ : IPriceDataStorage│ │ : IRawDataConnector │
│ MongoDB / CSV │ │ Tiingo · Yahoo · │
│ │ │ Quandl · FMP · CSI │
└────────────────────┘ └───────────────────────┘
▲
┌──────────────────────────────────────────────────┐
│ Web (MVC) · Jobs (sync) · FileGenerator (ETL) │
│ Genetic · RandomForest · Charting (WPF) │
└──────────────────────────────────────────────────┘
03 The Core Idea: Fractal Events
Everything in the platform is built on one foundational concept — fractal classification. Each price bar is examined with a lookback/lookahead window and classified as a High, a Low, or Neutral, at four nested scales.
Reaction ──► Minor ──► Intermediate ──► Primary (smallest) (largest)
A Primary high is a high that dominates a large window; a Reaction high is a small local wiggle. Once every bar carries this four-tier classification, the rest of the analysis falls out of it: support/resistance levels come from where past fractal events clustered, cycles are scored by how often their resonance points land on fractal events, and trade signals fire on level breaches. Almost every later feature reduces to one question — "where did the fractal events land?" — which kept the codebase conceptually coherent as it grew.
04 PriceDataFeature: The Central Object
The heart of the pipeline is the PriceDataFeature — a raw OHLCV bar enriched with roughly 60 computed properties. A PriceDataFeatureGenerator runs three finders in sequence to build it.
Raw OHLCV bars
│
▼
┌──────────────┐ ┌──────────────┐ ┌─────────────────────────┐
│ EventFinder │─►│ LevelFinder │─►│ TechnicalIndicatorFinder│
│ fractal │ │ support / │ │ RSI, stochastics, MAs, │
│ High/Low/ │ │ resistance │ │ volatility, candlestick │
│ Neutral ×4 │ │ levels │ │ patterns, ~60 flags │
└──────────────┘ └──────────────┘ └─────────────────────────┘
│
▼
PriceDataFeature (stored in MongoDB, pre-computed offline)
The indicators include RSI with threshold flags, stochastic oscillators, moving-average crossovers, intraday/overnight volatility buckets, candlestick patterns (Doji, DragonFly, Gravestone), and higher-high/lower-low comparisons at Fibonacci-spaced lookbacks (1, 2, 3, 5, 8, 13, 21, 120 bars). Because computing these is expensive, features are generated offline by an ETL console tool and stored in MongoDB — the web layer just reads pre-computed features rather than recomputing them per request.
05 The Market Abstraction
Working with raw storage directly would be painful, so the Markets layer wraps it in a clean, lazy-loaded object model. A single BaseMarket exposes one collection per time level, and each collection only loads when first accessed.
BaseMarket
├─ Daily (lazy-loaded PriceDataCollection)
├─ Weekly "
├─ Monthly "
├─ Quarterly "
└─ Yearly "
UpdateableMarket adds live sync: it asks the connector for any bars newer than the last stored one, inserts them, and rolls the new daily data up into the weekly/monthly/quarterly/yearly views. TimeLevel is part of the compound key for every storage query — it's passed explicitly everywhere, never inferred.
06 Resolving Data Feeds
The MarketUniverse is the single factory for all of this. It resolves the correct data feed by matching a market's UpdateConnectorName against registered connector names — so adding a new data source is just registering one more connector, with no change to the analytics engine.
MarketData.UpdateConnectorName = "tiingo"
│
▼
MarketUniverse ──lookup──► { "tiingo": TiingoConnector,
"yahoo" : YahooConnector,
"fmp" : FmpConnector, ... }
│
▼
fully-wired UpdateableMarket
07 Keeping Data Fresh
A .NET Generic Host Windows Service (MarketSyncJob) runs on a 24-hour loop. It pulls every market from MongoDB, calls UpdateAll() on each, and inserts any new price bars from the live feed — keeping the local store current without manual intervention.
every 24h ──► MarketUniverse.GetUpdateableMarkets()
│ for each market
▼
UpdateAll() ──► fetch new bars
──► insert
──► roll up time levels
08 Web Layer, ML & Reflections
An ASP.NET Core MVC app sits on top for browsing and annotation. It never touches storage directly — controllers depend on service interfaces that orchestrate the MarketUniverse and feature store behind the scenes:
- Markets — paginated instrument list, a HighCharts OHLC viewer, and manual price-bar categorization that feeds labeled training data back into the system
- Cycles — define a cycle (first wave date + length) and project its wave positions forward onto the chart's date axis as an overlay
- Features — manage the pre-computed support/resistance chart annotations
The same feature pipeline feeds two offline ML experiments that treat the analytics output as training data. Genetic (GeneticSharp) evolves buy/sell rule sets against SPY daily data — it's also how the platform's default support/resistance parameters were originally tuned. RandomForest (Accord.NET) trains a C4.5 decision tree to classify trade direction from PriceDataFeature inputs, using a "perfect trade" oracle (buy every reaction low, sell every reaction high) to generate ideal labels. There's also an experimental computer-vision angle — a Gramian Angular Field pipeline that encodes price windows as image matrices.
The thing I'm most happy with is the layering. Because storage and feeds are pure interfaces, I've swapped MongoDB for CSV in the experiments, added providers like FMP and CSI Data without touching the analytics engine, and migrated the whole solution from .NET Framework 4.8 to .NET 8 — all without rewriting the core.