Case Study · Allmarkets

Crypto and stock marketportfolio tracking &trading platform.

Allmarkets is a crypto and stock market portfolio tracking and trading platform, connected to forty exchanges and answering for all of them through a single API. We built it end to end over three years: the ingestion fleet underneath, the normalized price on top, the historical database that swallows fifty million data points a day, and the platform traders and developers actually work in.

Data points stored daily: 50MData points stored daily
Exchanges connected: 40Exchanges connected
Single API: 1Single API

Engagement Overview

Allmarkets is a crypto and stock market portfolio tracking and trading platform. It reaches into dozens of exchanges, normalizes everything they return, and hands it back two ways: as a single REST and WebSocket API for developers, and as a platform where a trader can chart the market, screen it, track a portfolio against it and place an order on it. Both halves run on the same data, which is the whole point of building them together.

We built all of it, for three years, from the first service to the last release. That covered the ingestion fleet that stays connected to every exchange, the normalization and pricing layer that turns forty answers into one, the historical database underneath it, the API surface on top, and the web and mobile platform the data eventually shows up in.

It started as a crypto and Web3 product and it did not stay one. Partway through, equities came in alongside it, and the same pipeline that had been reconciling Kraken against Coinbase started reconciling exchange feeds for Apple and the Dow. Almost none of the infrastructure had to change, because none of it had ever been written to assume what kind of asset was moving through it.

50M
Data points stored daily: 40
Exchanges connected: 1
Single API

Engagement: End-to-end product development
Team: Full product team, design through infrastructure
Focus: Market data infrastructure, API, platform, trading
Working model: Owned delivery, roadmap to release

Stack

Frontend & mobile

JavaScript
React
React Native
Redux
Highcharts

Backend

Microservices
Node.js
.NET
Python

Data & storage

MongoDB
Redis
Firebase

Developer platform

SDK Development
API Documentation

Infrastructure & DevOps

AWS
Docker
Kubernetes

Integrations

REST & WebSocket APIs

The Challenge

There is no such thing as the single price of Bitcoin. Ask forty exchanges what it costs and you get forty answers, all of them real, and the gap between the cheapest and the most expensive is wide enough to be worth money. Nobody can watch forty order books at once.

So Allmarkets had to do two things at once: give you one honest number, and tell you where to buy and where to sell it. The number is a real time median across all forty feeds, recomputed as trades land, so a bad tick on one exchange cannot drag it around. The buy and sell side only works if every book stays live, because a cached price points you at a market that has already moved.

That meant every trading pair on every exchange, with no quiet hours to catch up in. Crypto never closes. Around fifty million data points a day, close to six hundred a second, all written into history while the same system served live prices.

The Solution

The system is a fleet of small services, each responsible for exactly one thing and nothing else, all of them writing into the same store and answering through the same API. Five stretches of it carried most of the weight.

The Allmarkets stocks overview: an Apple price chart under a live ticker strip, with a DOW-30 heatmap and the day's top winners and losers below it

One API over forty exchanges

Every exchange gets its own service, and that service knows only one thing: how to talk to that exchange. It holds the connection open, handles the rate limits, reconnects when the socket drops, and translates whatever comes back into the one schema everything downstream speaks. Symbols get mapped, decimals get normalized, timestamps get pinned to the exchange's own clock rather than ours. What a developer sees at the other end is a single REST and WebSocket API where asking for a pair returns the same shape whether it is sourced from one venue or thirty. Adding the forty-first exchange is one new service and no change anywhere else, and losing one is a gap in a source list rather than an outage.

Microservices
REST & WebSocket API
Data Normalization

The Allmarkets market screener: crypto assets on Kraken listed with price, trade volume, day range and change over 24 hours, 7 days, 30 days and a year

One price, and where to actually buy it

Aggregating forty feeds gets you forty numbers, which is not an answer. On top of the ingestion layer sits the part that decides what the price is: a normalized figure weighted across venues, with the outliers, the stale ticks and the thin books discounted rather than averaged in. From the same view of the market it also answers the question a buyer is really asking, which is not what does this cost but where should I buy it. The spread between exchanges on a liquid pair is real money, and the platform ranks venues on price, depth and cost so an order is placed where it is actually cheapest at that moment.

Price Normalization
Cross-Exchange Analysis
Venue Ranking

The Allmarkets overview: an asset price chart over a market heatmap and the day's top winners and losers

Fifty million data points a day, and all of them queryable

The historical database takes in around fifty million data points every day, repackages them into models that are actually readable, and stores them against the timestamp the exchange sent rather than the one we received. That distinction is what makes the archive trustworthy years later. On top of it, history is queryable by almost anything a trader would ask for: the moment a specific trade printed, the open, high, low, close and volume for any interval, a single pair on a single venue or the normalized view across all of them. A cron fleet keeps the aggregates current and Redis sits in front of the reads, which is why a two-year chart opens in the time it takes to click it.

Historical Data
OHLCV
MongoDB & Redis
Cron Fleet

A portfolio, and a way to act on it

Data is where the product starts and not where it stops. Users connect their exchange accounts once and the platform tracks the whole position across all of them: holdings, cost basis, realized and unrealized movement, allocation, and performance against the normalized price rather than whatever the venue happens to be quoting. From the same screen they can trade. Orders route to the connected exchange through the same service that reads its feed, so the price a user sees and the price they act on come from the same place. There is no second system for execution, which is the only way the two ever stay in agreement.

Portfolio Tracking
Trading & Order Routing
Exchange Accounts

The Allmarkets news feed: a filtered grid of market and blockchain stories with topic filters above it

Never miss the thing that moved the market

Prices explain what happened, not why. News from a long list of sources is pulled in continuously, deduplicated, sorted into blockchain, technology, market, business and research, and published on the platform within minutes of breaking. From there it goes wherever the user already is, by email, SMS or Slack, and the same channels carry price alerts on the assets they care about. Somebody watching one pair does not have to keep a tab open to find out it moved.

News Aggregation
Alerts
Email, SMS & Slack

And everything the platform does with it

Each of these is its own service on its own interval, reading the same normalized store. That is what lets any one of them get heavier, or fail, without the rest of the platform noticing.

Real-time heatmap
The whole market laid out at once, each asset sized and colored by how far it has moved. Its own microservice recalculates the grid on a fixed interval, so what is on screen is never a page load behind the market.
Top performers
Winners and losers over seven days, thirty days or year to date, computed continuously rather than on request, across crypto pairs and equities in the same list.
Technical charting
Candles, indicators, intervals from one minute to all time, and drawing tools, all rendered in Highcharts over the same normalized feed on desktop and phone.
Screener and watchlists
Filter the entire market down by the criteria that matter to you, then keep what survives in a watchlist that updates live and follows you across devices.
Exchange volume and share
Which venue is actually carrying a pair, broken down by traded volume and market share over any window from an hour to a year.
Derivatives and spreads
Live spreads between venues to surface arbitrage opportunity as it opens, with derivatives analytics sitting alongside the spot feed rather than in a separate product.

The Allmarkets platform on a phone, showing a live asset price chart and the market grid

Business Impact

Allmarkets finished as 3rd Product of the Day on Product Hunt, against ruthless competition from Google and Airbnb. The part we are prouder of is what came after: years at around fifty million data points a day, through the market weeks that broke charts elsewhere, without the architecture underneath ever needing a rewrite.

The microservice shape is what bought that. Exchanges could be added or dropped without redeploying, a source going down became a gap in a list instead of an outage, and whatever got heavy got scaled on its own. It is also why the pivot to equities did not need a second system: the pipeline had never been told what kind of asset it was carrying.