← Research Posts

The Hidden Cost of Buy-Side Platforms: Owning the Truth

The build-versus-buy decision, investment state and control of the buy-side technology stack.

Jakub Polec ·

Every fund, prop office, family office, and asset manager eventually faces the same strategic question:

Which parts of the investment stack should we buy - and which should we build?

Quick note for everyone who asked after my last post: by buy-side I mean firms that allocate capital directly: hedge funds, asset managers, family offices, prop desks and systematic/quant shops.

The naive answer is easy: buy what’s commoditized, build what creates edge.

The hard truth is that most of the real value (and risk) lives in the messy middle.

→ Market data isn’t edge - but bad market data destroys it.

→ A portfolio dashboard isn’t edge - but wrong portfolio state destroys decisions.

→ Risk reports aren’t edge - but stale risk creates false confidence.

→ Backtesting is not edge by itself - but a backtest that cannot be reproduced in production is worse than useless.

→ Cloud infrastructure is not edge - but poor deployment, secrets, backups, monitoring, and audit can turn a smart investment process into operational risk.

This is why build-vs-buy is no longer a procurement decision. It is an investment operating strategy decision.

Figure 1: The Hidden Cost of Buy-Side Platforms: Owning the Truth

The diagram above shows the 11 components and 6 layers that a complete, production-grade buy-side quant platform actually needs.

The platform problem is not the UI

Most people underestimate what a real buy-side platform needs because they look at the screen. They see charts, grids, dashboards, portfolio views, risk numbers, order tickets, reporting pages.

I have seen this mistake many times: the screen looks finished, but nobody can explain why the number is true.

That is not the platform. The platform is the machinery that makes those numbers true. A production-grade buy-side quant platform needs several layers working together.

If you build too much of it yourself → your best engineers become platform maintainers.

If you buy too much from vendors → your investment process slowly bends to vendor workflows.

Either way, you lose.

The cost illusion

We know, the cost of prototyping has collapsed. With LLMs, cloud APIs, open-source libraries, modern Python, React, DuckDB, Polars, Kafka, Postgres, Dagster, Mongo, Docker, and managed cloud services, a small team can build something impressive very quickly.

One person can build a convincing portfolio dashboard in a weekend. Or build a backtester literally in a few days.

But none of that means the firm owns a platform.

The real cost begins when the system must answer harder questions:

  • Which instrument did this ticker refer to on that historical date?

  • Did this backtest use data available at the time?

  • Was the universe membership point-in-time correct?

  • Which vendor version of fundamentals was used?

  • Did the risk run use today’s positions or yesterday’s?

  • Does the NAV in reporting match the NAV in analytics?

  • Did the broker, custodian, internal book, and risk engine agree?

  • Who changed the thesis, override, signal, allocation, or exposure limit?

  • Can the investment decision be reconstructed six months later?

  • If a pipeline failed on Friday night, would anyone know before Monday’s IC meeting?

  • If a database dies, can it be restored?

  • If a developer leaves, can the platform still be deployed safely?

That is where the economics change. You are no longer paying for features. You are paying for operational truth.

That is where platform ownership becomes expensive: not in the first build, but in keeping the truth consistent every day.

What firms usually buy now

At the lower layers, buying usually makes sense. Most firms should not build their own:

  • Cloud primitives

  • Object storage & Data Lake

  • Basic identity provider

  • Email infrastructure

  • Standard monitoring primitives

  • Market data access pipes & ETLs

  • Terminals / UI & API / SDK

  • Generic accounting exports

  • Vendor connectivity

  • Low-level infrastructure tooling

You can use AWS, GCP, Azure, OCI, Hetzner, Snowflake, Databricks, Grafana, GitHub / GitLab, Auth0, Okta, Bloomberg, Refinitiv, FactSet, Nasdaq Data Link, Polygon, FMP, CBOE, IBKR, prime broker files, custodian feeds, and many others.

That layer is not where most firms should differentiate. But it still needs architecture and people who know how to operate, build and predominantly manage that in a rigorous production environment. It’s very different from Python scripts running on your Mac.

Yet, buying cloud does not give you data lineage. Buying a market data API does not give you point-in-time truth. Buying Grafana does not give you operational discipline. Buying Snowflake does not give you an investment data model. Buying Bloomberg does not give you your portfolio state. Buying an OMS does not give you your research-to-production loop.

Vendors give you important pieces. The mistake is assuming the pieces will assemble themselves into an operating system.

Where QuantJourney fits

No single system owns the full investment stack. Data terminals are strong at market data access and terminal workflows. OMS/PMS systems are strong around orders, positions and operations. Backtesting tools are strong in research. Thesis and RMS tools cover parts of the decision process.

But the hardest problem is not any one of these categories. It is making them agree.

Figure 2: The Hidden Cost of Buy-Side Platforms: Owning the Truth

The middle layer is not one module you can buy or rewrite over a weekend. It is the result of many boring architectural decisions made consistently.

That is where we are building QuantJourney.

We are not trying to replace Bloomberg, the prime broker, the fund admin, or a top-tier OMS. QuantJourney is designed as a private-cloud middle layer (runs on GCP, AWS, Hetzner) for investment decision support: point-in-time data, portfolio state, risk, backtesting, thesis monitoring, reporting truth, audit and lineage.

The objective is simple: reduce research-production drift and make investment state reproducible.

If a signal worked in research, the live system should know exactly what definition was used. If risk changed, the platform should know whether it came from prices, positions, exposures, vendor revisions, corporate actions or manual overrides. If an IC asks six months later why a position was changed, the answer should not be hidden in Slack, Excel, PDFs and log files.

We have been building this quietly for more than two years. The first PoCs are planned for June/July 2026.

What we actually built differently

The middle layer is not one product. It is a set of architectural decisions that compound.

  1. Identity / Facts / Decisions are separated.

    Instruments, market data and portfolio decisions live in different logical domains. This prevents the common failure mode where one large database slowly mixes tickers, prices, users, positions and decisions into an unreproducible mess.

  2. Point-in-time is the default.

    Backtests, risk and reporting should see what was knowable at the time — not what the vendor says today after restatements, corrections and corporate actions.

  3. Research and production share definitions.

    A signal, factor, universe, exposure rule or thesis definition should not be rewritten five times across notebooks, backtests, live books, risk engines and reports.

  4. Audit and lineage are data, not logs.

    Who changed what, which vendor version was used, which risk run fed which report, and why a decision was made should be queryable.

  5. Deployment is part of the product.

    Secrets, migrations, backups, monitoring, observability and restore discipline are not “IT extras”. In a fund, they are part of investment control.

What firms should not outsource

At the other end, funds may build the parts that express how they actually invest.

That includes:

  • Signal definitions

  • Portfolio construction logic

  • Risk interpretation

  • Thesis monitoring

  • Regime assumptions

  • Scenario logic

  • Position sizing rules

  • Rebalance logic

  • Hedging logic

  • Research workflows

  • Investment committee process

  • Decision frameworks

  • Internal views of what matters

This is where edge lives.

A discretionary long/short fund, a systematic equity shop, a global macro office, a family office, and a quant pod should not all think in the same workflow.

Their investment logic should not be forced into the same vendor template. If your process is genuinely differentiated, you cannot fully outsource it. But that does not mean you should build everything around it from scratch.

That is the trap.

The cost of ownership & Capex/Opex

A realistic internal build is not one developer and a few dashboards. A serious internal buy-side platform needs some combination of:

  • Data engineer

  • Backend engineer

  • Quant developer

  • Frontend engineer

  • DevOps / platform engineer

  • Database / infrastructure ownership

  • Security and access control ownership

  • Product / workflow ownership

  • Ongoing support and maintenance

Even a lean team of 4–6 strong people costs real money once salaries, benefits, cloud, data vendors, security, management time, and opportunity cost are included.

For a small or mid-sized fund, the annual fully loaded cost of owning an internal platform can easily move into the high six figures or low seven figures before it becomes reliable. That is before time-to-market, key-person risk and the opportunity cost of pulling strong engineers away from investment work.

And that is before expensive data contracts, terminals, OMS/PMS licenses, admin systems, prime broker integrations, or external consultants.

The middle layer - we’re building - is where most firms underestimate the work to build this:

  • Security master / instrument master - the canonical identity of every asset, ticker, share class, contract, currency, corporate action, and historical mapping.

  • Market and reference data warehouse - not just storing prices and fundamentals, but knowing what was available at the time, what was corrected later, and which version downstream models used.

  • Research and backtesting environment - where signals, universes, factors, and assumptions can be tested without leaking future data into historical results.

  • PMS / IBOR (ABOR & IBOR) - the real portfolio book: positions, tax lots, cash, NAV, sleeves, exposures, corporate actions, and actual portfolio history.

  • OMS / EMS boundary - the line between portfolio intent, orders, execution, fills, broker state, and post-trade reconciliation.

  • Risk engine - factor exposure, VaR, stress tests, drawdowns, liquidity, concentration, hedging, and scenario impact.

  • Reconciliation layer - the boring but critical place where broker, custodian, internal book, risk, and reporting either agree or expose a break.

  • Reporting and investor-grade truth - the layer that turns portfolio state, performance, risk, and attribution into numbers a CIO, IC, client, or LP can trust.

  • Entitlements and permissions - who can see, approve, edit, trade, override, export, or explain each part of the investment process.

  • Audit and lineage - what changed, who changed it, when it changed, which data was used, and whether the decision can be reconstructed later.

  • Deployment, observability, and operational control - the part nobody wants to talk about until a data pipeline fails, a risk run is stale, or Monday’s IC pack is built on the wrong state.

Open full-size image ↗