In our previous article, we peeled back the curtain on how we built VTrade’s high-fidelity market execution engine to simulate real-world slippage and order-book friction. But calculating a precise execution price is only half the battle.
Once those orders clear, you hit the ultimate state-tracking nightmare: Portfolio Intelligence.
On VecTrade.io, users expect to see their Total Portfolio Value (NAV), Daily P&L, Sector Allocations, and 7-day Equity Curves update instantly whenever a live asset price ticks. If you try to achieve this naively by running heavy SQL SUM() or aggregation joins across a massive ledger of open positions every time a price updates, your database CPU will spike to 100%, and your platform will crash.
Here is how we architected an event-driven, cache-first calculation pipeline capable of streaming real-time portfolio analytics to thousands of concurrent users without breaking a sweat.
📘 Building your own algorithmic trading dashboard or looking for our exact SDK structure? Check out the full Python/TypeScript specifications in the docs.vectrade.io SDK docs and explore our open-source tools on GitHub.
The Architectural Fallacy: On-The-Fly Aggregation
Let’s define the math we are dealing with. A user's total Net Asset Value ( ) at any given millisecond is represented by:
Where is the quantity of asset held, and is its current market price.
If a platform has 20,000 active traders, each holding a diversified basket of 15 assets across our supported equities, crypto, and commodities, that represents 300,000 active position states. Now consider that the live price feed for high-liquidity assets (like BTC or AAPL) can push multiple updates per second.
Re-evaluating the complete equation across your entire database for every micro-tick is architectural suicide. To handle this throughput, VTrade decouples ingestion from storage using a reactive, pipeline-oriented design.
The Streaming Analytics Pipeline
To process incoming market telemetry at scale, we isolate components into three highly specialized layers: Ingestion, Evaluation, and Distribution.
1. Ingestion Layer
Instead of dumping inbound WebSocket traffic directly into a relational model, we feed our multi-asset price stream into a central Redis Pub/Sub cluster. This tier functions as a high-throughput, low-latency buffer, filtering and normalizing incoming asset quotes before they reach our business logic layer.
2. Evaluation Workers: Delta-Based Processing
The real magic happens in our horizontal scaling cluster of Evaluation Workers. When an asset's price updates (e.g., ETH moves from $3,400 to $3,405), a worker pulls the update.
Crucially, the worker does not recalculate the affected portfolios from scratch. Instead, it utilizes an in-memory Reverse Position Index to locate exactly which active user IDs currently hold ETH. It then applies an incremental delta-based calculation to compute the net change in unrealized P&L:
The worker executes an atomic command to update only that specific user’s portfolio cache values. This transforms an incredibly expensive global database scan into an ultra-fast, predictable cache mutation.
State Management Strategy: Hot vs. Cold Storage
To maintain extreme snappiness while capturing rich historical trends for advanced analytics, VTrade partitions its data layer into two distinct storage topographies:
| Metric Type | Storage Medium | Access Pattern | Lifecycle / Expiry |
|---|---|---|---|
| Active NAV, Daily P&L, Open Positions | Redis Hashes (In-Memory) | Read/Write on every market tick | Ephemeral; destroyed or archived upon position liquidation |
| Sector Allocation Matrix | Redis Sorted Sets (ZSET) | Mutated only on order fills | Evaluated dynamically during active trading sessions |
| Historical Equity Curves (7d/30d/1y) | TimescaleDB (Time-Series) | Written on EOD/Hourly snapshots | Permanent analytical record; optimized via hyper-tables |
| Detailed Audited Trade Ledger | PostgreSQL (Relational) | Write-once, read-rarely | Permanent transactional history for risk reporting |
Delivering the Dashboard Grid
When a trader signs into their command center, the top-level Hero Card and Main Content Area display information fetched instantly from the Hot Storage Layer.
Because this state lives completely inside RAM, initial page renders take less than 15ms. Once loaded, the UI hands off responsibility to our WebSocket gateway, which pumps down subsequent delta changes as they pass through the Evaluation cluster.
Real-Time Asset Attribution and Diversification
Part of what makes the VTrade architecture unique is its ability to track automated risk metrics—such as verifying if a user has unlocked the Diversified Badge by keeping exposure distributed across 5+ distinct economic sectors simultaneously.
To implement this without scanning the position table constantly, we track sector distributions using denormalized metadata maps inside Redis. When an order completes inside the execution engine, it emits an asynchronous message to our Kafka Event Bus.
A background consumer intercepts the event, resolves the asset's structural sector classification (e.g., mapping TSLA to Consumer Discretionary or BTC to Layer 1 Crypto), and immediately alters that portfolio’s atomic allocation percentages.
If the allocation crosses a predefined structural threshold, an alert is automatically published to our gamification processor.
Architecture Lessons Learned
By separating data into distinct, task-oriented storage lanes and moving entirely to delta-based state updates, we eliminated database resource constraints entirely. The portfolio pipeline handles highly volatile market events seamlessly.
If you want to view our interface layouts or inspect the platform navigation blueprints we use to wire these data layers up to our dashboard frontends, head over to the VTrade Platform Guide on docs.vectrade.io.
In our next post, we will take this highly accurate, real-time data layer and explore how we layered true intelligence over it. We will deep-dive into the development of our Agentic AI Copilot, mapping out how we wired a Large Language Model to 48 autonomous FinTech tools while maintaining unbreakable state-mutation boundaries.
Top comments (0)