Technical case study of a trading analysis platform built with Node.js, TypeScript, Fastify, Electron, React, Zustand and stable JSON contracts.
This repository is a public, documentation-only case study. The original source code, credentials, trading logic, proprietary scoring rules and production payloads are private.
This project presents a complete trading-analysis software system composed of two main applications:
| Layer | Name | Purpose |
|---|---|---|
| Backend | Market Analysis Backend | Collects and normalizes market data, builds technical snapshots and exposes stable JSON contracts. |
| Desktop App | Meridian | Electron-based desktop app that consumes backend analysis and turns it into an operational UI. |
The system was designed to transform raw market data into structured, readable and actionable analysis views, while keeping backend logic, data contracts and desktop UI clearly separated.
Trading analysis can become fragile when market data, calculations, manual notes, JSON files and UI interpretation are handled separately.
This platform addresses that problem by centralizing the workflow:
- Market data ingestion from an external trading data source.
- Normalization into a consistent internal structure.
- Snapshot generation for technical analysis.
- Analysis output through stable JSON contracts.
- Desktop visualization through a dedicated Electron app.
- Sequential pair scanning with controlled request timing.
- Clear visual distinction between different analysis states.
The goal was not only to display market data, but to build a reliable software pipeline from data acquisition to user-facing decision support.
flowchart LR
A[External Market Data Source] --> B[Market Integration Layer]
B --> C[Normalization Layer]
C --> D[Snapshot Builder]
D --> E[Analysis Engine]
E --> F[Stable JSON Contract]
F --> G[Meridian Preload API]
G --> H[React Renderer]
H --> I[Trading Analysis UI]
| Area | Responsibility |
|---|---|
| Market integration | Retrieves market bars/context from an external data source. |
| Normalization | Converts heterogeneous data into a stable internal format. |
| Snapshot builder | Produces a technical snapshot for a symbol and time context. |
| Analysis engine | Evaluates the snapshot and returns structured signals, levels and reasons. |
| JSON contracts | Keeps backend and desktop app compatible. |
| Desktop UI | Presents analysis, state, reasons, levels and pair scanning workflows. |
| Electron security | Separates Main, Preload and Renderer responsibilities. |
- Symbol-based trading analysis workflow.
- Multi-timeframe technical snapshot generation.
- Backend normalization before UI consumption.
- Stable JSON output consumed by a desktop application.
- Operable / non-operable status support.
- Score and probability visualization.
- Signals, levels and reason panels.
- Workspace/tabs model for multiple analyses.
- Sequential scan of enabled pairs.
- Controlled delay between backend requests.
- Persistent desktop context.
- Clear empty, loading and error states.
- Safe Electron boundary through Main / Preload / Renderer separation.
The backend is responsible for transforming raw trading data into a stable analysis output.
Main technical areas:
- Node.js and strict TypeScript.
- Fastify-based HTTP API.
- Zod validation for inputs and outputs.
- Layered architecture with routes, services, clients, schemas and domain helpers.
- External market data integration encapsulated behind client/repository layers.
- Snapshot generation as an intermediate analysis structure.
- Output contracts designed for frontend compatibility.
- Controlled error handling and predictable responses.
- Environment-based configuration and deployment readiness.
Read more: docs/backend.md
Meridian is the desktop application that consumes the backend and translates analysis into an operational interface.
Main technical areas:
- Electron + React + TypeScript.
- Zustand for state management.
- MUI for UI composition.
- Secure Electron architecture using Main, Preload and Renderer separation.
- Typed IPC/API boundaries.
- Workspace and tab-based analysis flow.
- Pair scanning workflow with sequential requests.
- Dedicated visual treatment for analysis states.
- Loading, error and empty states designed as part of the product.
Read more: docs/desktop-app.md
sequenceDiagram
participant User
participant Meridian as Meridian Desktop App
participant API as Backend API
participant Market as Market Data Source
User->>Meridian: Selects trading pair
Meridian->>API: Requests analysis
API->>Market: Fetches market data
Market-->>API: Returns raw data
API->>API: Normalizes data
API->>API: Builds snapshot
API->>API: Runs analysis
API-->>Meridian: Returns stable JSON contract
Meridian->>Meridian: Maps response to UI state
Meridian-->>User: Displays analysis view
Read more: docs/data-flow.md
| Document | Description |
|---|---|
product-overview.md |
Product context, user problem and scope. |
architecture.md |
System architecture and component responsibilities. |
backend.md |
Backend design, modules and analysis pipeline. |
desktop-app.md |
Meridian desktop app architecture and UI workflow. |
data-flow.md |
End-to-end flow from market data to UI. |
json-contracts.md |
Contract-first integration between backend and desktop app. |
trading-workflow.md |
Analysis, scan pairs and decision visibility workflow. |
security.md |
Safe public notes about authorization, secrets and Electron boundaries. |
interview-talking-points.md |
Recruiter and technical interview talking points. |
The current screenshots show the main Meridian desktop workflow using non-sensitive visual examples.
Included screenshots:
| Screenshot | Description |
|---|---|
dashboard.png |
Main dashboard and analysis overview. |
new-analysis-flow.png |
New analysis workflow for selecting and processing a market pair. |
non-operable-analysis.png |
Example of a non-operable analysis result. |
scan-pairs.png |
Pair scanning workflow with controlled request handling. |
workspaces-tabs.png |
Workspace tabs used to manage multiple analysis contexts. |
An operable analysis screenshot can be added later when a valid market setup is available. The current version intentionally avoids fabricated or mocked trading signals.
Screenshots are stored under:
assets/screenshots/
See: assets/screenshots/README.md
This public case study does not include:
- Source code.
- Trading strategy rules.
- Exact scoring thresholds.
- Proprietary decision logic.
- Production payloads.
- Tokens, headers or credentials.
- Private backend URLs.
- Full internal schemas.
- Sensitive broker or account data.
This project demonstrates practical experience with:
- Building backend systems around normalized data pipelines.
- Designing stable API contracts for a real consumer application.
- Working with strict TypeScript in backend and frontend contexts.
- Building an Electron desktop app with safer architecture boundaries.
- Managing complex UI state with workspaces and pair-scanning workflows.
- Separating integration, domain analysis and presentation responsibilities.
- Designing software around maintainability, compatibility and operational clarity.
This repository is a software engineering case study. It does not provide financial advice, trading recommendations or a public trading strategy.