What It Actually Costs to Run a Self-Hosted Crypto Exchange (Real Numbers, 2026)

Team Codono — Tue, 15 Sep 2026 07:19:16 +0000

Every "how to start a crypto exchange" article hand-waves the operating costs. After helping
100+ teams deploy self-hosted exchanges since 2017, here are the real numbers — and where
teams consistently over- and under-budget.

The license is the cheap part

SaaS exchange platforms charge $2,000–$10,000/month plus, commonly, a revenue share.
A source-code license is a
one-time purchase ($1,899–$12,500 depending on tier). Over five years the difference is
not subtle: $1,899 once versus $120,000+ in subscription fees before revenue share.

But the license was never the real cost of running an exchange. Here's what is.

Infrastructure: $200–$800/month

A mid-size deployment (10k registered users, ~500 concurrent) runs comfortably on:

App + matching: 8 vCPU / 32GB — $150–300/mo
Database (MySQL primary + replica): $80–150/mo
Redis + queue: $40–80/mo
Blockchain access: free public RPCs work at low volume; budget $50–200/mo for managed nodes (Alchemy/QuickNode tier) once deposit scanning gets serious

Teams over-budget here. You do not need Kubernetes on day one. You need boring,
monitored VMs and a tested restore procedure.

Where teams under-budget

1. Compliance operations — $500–5,000/month. KYC verifications cost $0.50–2.00 each
at providers like Sumsub or Shufti. AML screening on withdrawals adds more. The software
integrates the providers; the per-check invoices are yours. At 1,000 signups/month you're
paying four figures.

2. Liquidity. An empty order book kills an exchange faster than any technical failure.
Options, cheapest first: aggregate external venues through a
liquidity engine (near-free, spreads
slightly wider), market-maker agreements ($2k–10k/mo), or internal inventory
(capital-intensive). Most launches should start with aggregation and graduate.

3. The security budget nobody plans. One competent pentest before launch: $5k–15k.
Bug bounty pool: $1k/mo minimum. Cold-wallet ceremony hardware: $500 once. This is the
cheapest insurance in an industry where the alternative is a headline.

4. Banking/fiat rails. Highly jurisdiction-dependent; a fiat gateway integration is
a software problem (solved), but the banking relationship behind it is a
months-of-meetings problem (not solved by any vendor, ours included).

A realistic year-one budget

Item	Self-hosted	SaaS equivalent
Platform	$1,899–12,500 once	$24k–120k/yr + rev share
Infra	$3k–10k	included
KYC/AML ops	$6k–60k	same (always pass-through)
Security	$10k–20k	partially included
Liquidity	$0–50k	often bundled, less control
Total	~$25k–150k	~$40k–250k+

The self-hosted column buys an asset (code + data + infrastructure you own); the SaaS
column buys a dependency. Which is right depends on your team — if you have zero DevOps
capability, SaaS's premium is buying real value. If you have even one competent
infrastructure engineer, ownership economics win by year two.

Full platform details, public pricing included, at codono.com —
or dig into the complete module list.
Questions about any line item, ask in the comments; I've watched teams get every one
of these wrong.

Building a Production-Grade Crypto Exchange: Architecture Deep-Dive

Team Codono — Mon, 27 Jul 2026 10:33:55 +0000

Most crypto exchanges die in the same place: not the UI, not marketing — the architecture underneath. A trading platform looks like a CRUD app from the outside, but it behaves like a real-time system with money at stake. After working through the components of a production-grade exchange, here is the architecture that actually holds up, and the failure modes of the shortcuts.

1. The matching engine is a state machine, not a service

The naive approach is a matching engine that reads and writes a database per order. It collapses around a few hundred orders per second.

A production engine keeps the entire order book in memory, organized as price-level queues with strict price-time priority. Every incoming order moves through one deterministic path:

validate → risk check → match against book → persist event → publish

Two details matter more than the algorithm:

Single-writer principle. One thread (or actor) owns the book per trading pair. No locks, no races, deterministic replay.
Event sourcing. Persist the intent and the outcome as an append-only event log. If the process crashes, you rebuild the book by replaying events — not by trusting the last database state.

Sub-5ms matching latency is achievable with boring technology when you stop hitting disk on the hot path.

2. Wallet infrastructure: separation of duties

The wallet layer is where exchanges lose funds. The architecture that survives:

Hot wallet — small float, online, handles withdrawals up to a threshold.
Warm/cold storage — the treasury. Multi-sig or MPC, withdrawal requires human approval.
A reconciliation daemon — independently scans every chain and asserts that on-chain reality matches the ledger. It never trusts the deposit service's word.

Deposits and withdrawals are state machines with explicit confirmation counts per chain. "Crediting on 1 confirmation" for BTC is how you get double-spent.

3. The ledger is the product

Every balance change — trade, deposit, withdrawal, fee — is a double-entry ledger entry. Not a balance column you increment.

This gives you three things for free: complete audit trails, trivial reconciliation, and the ability to answer "why does user X have Y" years later. Exchanges that skip this spend their second year writing it anyway.

4. Liquidity from day one

An empty order book is a death spiral: no liquidity → no traders → no liquidity. Two proven patterns:

Internal market-making — a quoting bot that maintains a tight two-sided book on your own venue, funded from your treasury.
External liquidity bridging — mirror depth from a major exchange and hedge fills back-to-back. Your users see a deep book; your risk desk sees net-zero exposure.

5. KYC, admin, and the boring 40%

Roughly 40% of exchange code is not trading: KYC review queues, role-based admin access, fee configuration, withdrawal approvals, and audit logs. The architectural rule: admin actions are signed, permissioned operations in the same event log as trades — never direct database writes.

6. Buy vs. build

Building all of this from scratch is an 18-month, multi-million-dollar project — and then you maintain it forever. The pragmatic middle ground that has emerged is production-grade exchange software with full, unencrypted source code: you own the stack, can audit every wallet line, modify the fee engine, and deploy on your own infrastructure — without writing a matching engine from zero.

This deep-dive reflects the architecture used by Codono, self-hosted crypto exchange software with full source code — spot, futures, margin, and P2P modules, a 50+ chain wallet system, and native apps under a one-time license. Live demo and docs at codono.com.

What architectural piece bit you hardest when building trading infrastructure? Matching engine determinism, wallet reconciliation, or liquidity?

DEV Community: Team Codono