Building FinSight: An AI-Assisted Financial Analytics Platform

FinSight started as a question I kept coming back to: what would a financial analytics product look like if market data, portfolio context, research notes, news, and AI-assisted analysis all lived in the same system instead of across five disconnected tools?

I wanted something that felt like a real product, not a dashboard demo. That meant going past charts and building the plumbing behind them: ingestion jobs, transformations, warehouse models, product APIs, authentication, and delivery workflows outside the browser.

What FinSight Does

FinSight is a full-stack financial analytics platform built around four core surfaces: Markets, Analysis, Portfolio, and News. The app gives users benchmark context, sector summaries, portfolio tracking, structured research notes, article feeds, and a query layer that turns natural-language prompts into data-backed responses.

Market overview with movers, sector summaries, volatility signals, and ticker context
Portfolio tracking with holdings, watchlist, P&L, concentration, and alert summaries
Research notes board for thesis, risk, review, and exit-trigger workflows
News feed with source article pages and links back to the original publishers
Telegram integration for account linking, portfolio briefs, and delivery workflows

Architecture

The system combines external market and news providers with a small analytics platform behind the scenes. Data moves through ingestion jobs, streaming transport, warehouse modeling, and an application layer that serves both the UI and the AI-assisted analysis experience.

Alpaca / Twelve Data / Brave News / yfinance
                    |
                    v
      Ingestion + streaming jobs (Python)
                    |
        +-----------+-----------+
        |                       |
        v                       v
      Kafka                  Spark
        |                 indicator transforms
        +-----------+-----------+
                    |
                    v
               dbt + DuckDB
                    |
                    v
                 FastAPI
           +--------+--------+
           |        |        |
           v        v        v
         React    Query   Telegram
                   layer     bot

Data Pipeline

The pipeline is where the product became interesting. Raw market data comes in from providers like Alpaca, Twelve Data, and yfinance. From there, jobs push data through Kafka and Spark to compute indicator-oriented features such as RSI, SMA, VWAP deviation, daily percent change, and volume z-scores.

DuckDB acts as the analytics warehouse, with dbt shaping the raw and transformed data into serving-friendly marts for market snapshots, sector summaries, anomaly detection, and query context. That structure makes the frontend fast and gives the analysis layer a much cleaner surface to work against.

Application Layer

FastAPI sits at the center of the product. It exposes endpoints for market snapshots, news, portfolio operations, notes management, query handling, and Telegram workflows. I liked this setup because it kept the product contract explicit while still leaving room for batch jobs and external services around it.

Area	Purpose
/market-snapshot	Serves market overview, sector context, and top-level dashboard data
/market-news	Provides aggregated market news and article detail views
/query	Handles natural-language analysis requests against structured context
/portfolio	Supports holdings, watchlist, performance, and summary logic
/notes	Backs the research notes board and workflow state
/telegram	Coordinates account linking and delivery flows

AI-Assisted Analysis

One of the more interesting parts of FinSight is the query layer. Instead of limiting the app to predefined charts and cards, I added a Qwen-oriented text-to-SQL style flow through Groq so users can ask analytical questions in plain language. The backend then maps those prompts into structured query behavior across live, historical, news, watchlist, and portfolio-aware contexts.

That matters because financial questions are rarely isolated. A good answer often needs both market context and user context. If someone asks what names in their portfolio look weak, the system should understand holdings, recent moves, and relevant market signals together.

Product Experience

On the frontend, I kept the experience organized around product areas rather than around the backend itself. Markets gives the snapshot view. Analysis handles natural-language Q&A. Portfolio covers holdings, watchlist, alerts, and notes. News gives a dedicated feed plus article pages. The app is also responsive, so the experience still works cleanly on smaller screens.

I also wanted the product to extend beyond the web UI. Telegram made that possible by giving FinSight a delivery channel for account linking, briefs, and alerts, which makes the project feel more like a usable product than a browser-only prototype.

What I Learned

Product cohesion matters as much as infrastructure. The value was not just in building a pipeline. It was in making market data, portfolio context, news, and notes work together.
DuckDB and dbt are a strong pairing for lightweight analytics products. They gave me a fast local warehouse loop without overcomplicating the stack.
AI features get better when the underlying data model is disciplined. The query layer became much more useful once the warehouse and API surfaces were clearly shaped.
Delivery channels change how a product feels. Adding Telegram pushed the project beyond a dashboard and closer to a real user workflow.

Live Demo GitHub