PROPELOO

EXCHANGE / TRADING INFRASTRUCTURE

Build trading infrastructure where execution reliability is the product.

PROPELOO engineers cryptocurrency exchange systems — matching engines, order management, custody, liquidity infrastructure and the compliance systems required to operate. An exchange is not a trading interface. It is a financial institution with a software product. The architecture decisions — matching engine design, custody model, liquidity strategy — define both what the platform can do and what regulatory posture it must take.

The matching engine is not the hard part of building an exchange. The custody, compliance and operational risk infrastructure is.

Most exchange development projects underestimate what an exchange actually is. The order matching logic is well-understood. The hard engineering is the custody model that protects user funds, the risk engine that prevents liquidation cascades, the liquidity management that keeps spreads tight, the KYC/AML infrastructure that satisfies regulators, and the operational monitoring that catches problems before they become incidents. An exchange that goes down during a market spike is not a software problem. It is an architecture problem that was visible in week two of the project.

The full stack of a trading infrastructure platform.

A functioning exchange is at minimum six independent engineering systems — each with its own failure modes, each a point of competitive differentiation or existential risk.

System Layers

  • Order Management Layer: Order entry, validation, routing, lifecycle management, position tracking, order book state
  • Matching Engine: Price-time priority matching, partial fill logic, trade confirmation, atomic order book updates
  • Risk Engine: Pre-trade risk checks, margin calculation, position limits, circuit breakers, forced liquidation
  • Custody & Settlement: Hot/cold wallet management, MPC key operations, deposit detection, withdrawal processing, settlement finality
  • Data & Compliance Layer: Market data feeds, trade history, OHLCV aggregation, KYC/AML workflows, regulatory reporting, audit trail

Core Technical Capabilities

  • Matching Engine Design

    Price-time priority CLOB matching engine with deterministic order processing, partial fill mechanics, atomic state updates and throughput benchmarked to the target trading volume.

  • Order Management System

    Order lifecycle management — creation, partial fill, cancellation, expiry — with position tracking, order history and consistent state under concurrent load.

  • Custody Architecture

    Hot wallet, cold storage, MPC-based signing and HSM integration — with withdrawal limits, multi-approval flows and real-time balance reconciliation.

  • Liquidity & Market Making

    Market maker API design, spread management, inventory rebalancing, AMM backstop liquidity and launch liquidity strategy for new trading pairs.

  • KYC/AML Integration

    Identity verification workflow, document checking, sanctions screening, ongoing transaction monitoring and regulatory reporting for the operating jurisdictions.

  • Risk Engine

    Pre-trade position checks, real-time margin calculation, forced liquidation triggers, insurance fund mechanics and circuit breakers for market stress events.

How we think about exchange infrastructure.

A trading interface is easy to build. Execution infrastructure that handles partial fills, race conditions, custody security and regulatory reporting isn't.

  • Custody is the existential risk

    Every major exchange that has failed catastrophically failed at custody — either through theft, mismanagement or fraud. The custody architecture is not an implementation detail. It is the primary security architecture of the platform, and it must be correct before any other engineering begins.

    Axiom:

  • The matching engine must be deterministic

    Race conditions in order matching create states that are undefined by the rules — and exploitable by anyone who discovers them. The matching engine must process orders in a strict, linearisable sequence with no paths to inconsistent state under any load condition.

    Axiom:

  • Liquidity is the product, not the feature

    An exchange with correct technology and no liquidity is an empty restaurant. Market maker API design, spread parameters, initial seeding strategy and pair prioritisation must be part of the architecture conversation before launch.

    Axiom:

  • Compliance posture is an architecture decision

    The custody model, user data architecture, geographic availability and product features collectively determine what regulatory requirements apply. These decisions are not separable from the technical architecture and must be made together.

    Axiom:

The decisions that define an exchange platform.

Every one of these choices has regulatory, operational and competitive implications. Most cannot be changed without a full rebuild.

  • Centralised vs hybrid vs DEX model

    Impact: The model choice determines regulatory requirements, custody liability and the engineering complexity of the matching layer. CEX and DEX are fundamentally different systems, not different configurations of the same system.

    • Fully centralised (CEX) — highest performance, custody liability, full regulatory surface
    • Hybrid (off-chain matching, on-chain settlement) — performance + settlement trustlessness, complex architecture
    • Fully on-chain DEX — maximum trustlessness, throughput limited by chain, no custody liability
  • Order book vs AMM liquidity

    Impact: CLOB requires a market maker strategy at launch. AMM requires capital efficiency optimisation. The choice defines the go-to-market liquidity approach.

    • Central limit order book — price discovery, professional market maker support, needs liquidity providers at launch
    • AMM (Uniswap-style) — permissionless liquidity provision, always liquid, slippage on large orders
    • Hybrid CLOB + AMM backstop — order book for institutional, AMM for guaranteed liquidity floor
  • Custodial vs MPC vs multi-sig custody

    Impact: Custody architecture is the single most consequential security decision in exchange design. Hot wallet compromise is the primary attack vector against exchanges. MPC or multi-sig is the minimum viable security model for any platform holding significant user funds.

    • Exchange-managed hot wallet — simplest, single point of failure, regulatory exposure
    • MPC-based signing — keys split across parties, no single point of compromise, operational complexity
    • Multi-sig (Gnosis Safe or equivalent) — threshold signing, auditable, slower for high-frequency withdrawals
    • Cold storage + hot wallet — tiered model, most assets in cold, operational complexity
  • Synchronous vs async matching

    Impact: Async matching increases throughput but requires clients to handle intermediate states — pending, partially filled, cancelled. Market data feeds and order status must be designed consistently around the async model.

    • Synchronous — blocking order confirmation, simple client state model, throughput limited by confirmation latency
    • Async with callbacks — non-blocking, higher throughput, complex client state management for partial fills
    • Event-driven with WebSocket push — highest throughput, requires robust event delivery guarantees
  • White-label vs custom build

    Impact: White-label platforms reduce time-to-market but create a ceiling on performance and differentiation. Custom matching engines are a competitive advantage that compounds as trading volume grows.

    • White-label (AlphaPoint, OpenDAX, Peatio) — fast to market, limited differentiation, licensing cost
    • Custom build — full control, higher initial cost, competitive moat through infrastructure quality
    • White-label with custom matching engine — hybrid, proprietary performance on commoditised UX
  • Regulatory jurisdiction

    Impact: Each jurisdiction adds KYC/AML requirements, reporting obligations and potential capital requirements. The compliance infrastructure required for US + EU + APAC is a full engineering workstream, not a configuration.

    • Single jurisdiction — simplest compliance model, limited addressable market
    • Multi-jurisdiction from launch — broader market, compliance overhead multiplies per jurisdiction
    • Offshore jurisdiction first — faster launch, market access constraints, banking partner limitations

What exchange infrastructure becomes.

  • Spot Trading Exchange

    Full spot exchange infrastructure — CLOB matching engine, order management, user accounts, custody, market data and KYC/AML for a regulated spot trading platform.

  • Derivatives / Futures Platform

    Perpetuals or options infrastructure with mark price oracle, funding rate mechanism, margin engine, liquidation bots and insurance fund mechanics.

  • Copy Trading Platform

    Signal provider performance tracking, automated trade replication with proportional sizing, risk limit controls and performance-based fee distribution.

  • OTC / Dark Pool

    Large-block bilateral trading infrastructure with RFQ mechanics, price negotiation, settlement coordination and minimal market impact through off-book execution.

  • White-label Exchange Product

    Exchange infrastructure platform designed for white-label deployment — multi-tenant architecture, client configuration, isolated order books and branded client portals.

  • Token Launchpad with Trading

    IDO infrastructure with price discovery mechanics, initial trading period management, anti-bot protection and transition to continuous trading after launch.

The stack depends on throughput requirements, custody model and regulatory posture.

Exchange infrastructure is latency-sensitive. Language and architecture choices at the matching and risk layer have measurable impact on execution quality.

  • Matching & OMS

    Stack: Go / Rust (matching engine), Redis (order book state), Kafka (event streaming), PostgreSQL (trade ledger), gRPC (internal services)

  • Custody & Keys

    Stack: MPC (Fireblocks / in-house), HSM (AWS CloudHSM), Gnosis Safe, Bitcoin Core / Ethereum nodes, Blockchain API providers

  • Risk & Compliance

    Stack: Custom risk engine (Go), Chainalysis / Elliptic (AML), Synaps / Onfido (KYC), Compliance reporting pipeline, Transaction monitoring

  • Market Data

    Stack: WebSocket server (Go/Node), OHLCV aggregation, Historical trade API, TradingView charting library, CoinGecko / CoinMarketCap feeds

  • Backend & API

    Stack: Node.js / Go REST API, GraphQL (client-facing), JWT / OAuth2 auth, Rate limiting (Redis), Admin panel (React)

  • Infrastructure

    Stack: AWS (multi-region), Kubernetes, Terraform, Datadog, PagerDuty, WAF / DDoS protection

Exchange security is operational, not just technical.

The largest exchange failures were not software bugs. They were custody failures, operational lapses and architectural decisions that concentrated risk in a single point.

  • Custody Attack Vectors

    Hot wallet private keys are the highest-value target in trading infrastructure. HSM storage for signing keys, MPC threshold schemes that require multiple parties to sign, cold storage tiering for the majority of assets and withdrawal limits with time delays are the baseline requirements for any platform holding significant user funds.

  • API Key Security

    Exchange API keys with withdrawal permissions are an active phishing and credential theft target. Per-key permission scoping (read-only vs trade vs withdraw), IP allowlisting, suspicious usage alerting and forced re-authentication for withdrawal key generation are required on every exchange product.

  • Front-running & MEV

    For on-chain or hybrid exchanges, order submission visibility in the mempool allows front-running by searchers. Commit-reveal schemes, private relayers, batch auction mechanics or intent-based routing are the design-level solutions — not mitigations.

  • DDoS on Trading Engine

    Exchanges are targeted with application-layer DDoS specifically during market volatility — when outages cause the most user harm and reputational damage. Rate limiting at the API gateway, order-to-trade ratio enforcement and circuit breakers that degrade gracefully under load are required.

  • Wash Trading Detection

    Artificial trading volume damages market integrity, attracts regulatory scrutiny and misleads liquidity providers. Order flow analysis, account relationship detection, velocity rules and automated account suspension for suspicious patterns are required for any exchange seeking institutional credibility.

  • Withdrawal System Security

    Withdrawal processing is the highest-risk operational workflow. Velocity limits, withdrawal address allowlisting with time delays, anomaly detection on withdrawal patterns and manual review queues for large withdrawals are layered controls that reduce the blast radius of any single point of compromise.

From trading model to live exchange.

  1. 01. Exchange Architecture

    Trading model selection, custody architecture, matching engine design, compliance surface mapping, liquidity strategy and regulatory jurisdiction analysis.

  2. 02. System Design

    Matching engine specification, order lifecycle definition, custody flow design, risk parameter framework and integration architecture for all dependent systems.

  3. 03. Core Infrastructure

    Matching engine and OMS development, custody system build, risk engine implementation and market data infrastructure — highest reliability components first.

  4. 04. Compliance & KYC

    KYC/AML workflow integration, sanctions screening, transaction monitoring, regulatory reporting pipeline and compliance documentation for target jurisdictions.

  5. 05. Frontend & APIs

    Trading interface, order management UI, account management, charting integration, public REST/WebSocket API and admin panel.

  6. 06. Security & Load Testing

    Penetration testing of custody flows, API security review, load testing of matching engine to 10x projected peak, DDoS simulation and incident response runbook.

  7. 07. Launch & Operations

    Staged launch with trading pair limits, market maker onboarding, monitoring dashboards, on-call protocol and post-launch liquidity management.

Frequently Asked Questions

What is the difference between a CEX, DEX and hybrid exchange?

A CEX (centralised exchange) holds user funds in custody and runs matching entirely off-chain — highest performance, full custody liability. A DEX runs matching and settlement on-chain, users retain custody — no custody liability, performance limited by blockchain throughput. A hybrid runs matching off-chain for performance but settles trades on-chain, giving users self-custody without sacrificing execution speed. Each model creates a different regulatory surface, custody liability and engineering architecture. The choice is not a configuration — it is a fundamental product decision.

How does a matching engine work?

A matching engine maintains an order book — a sorted list of buy and sell orders at each price level. When a new order arrives, the engine checks whether it can be matched against existing orders at the price (for limit orders) or immediately (for market orders). If a match is found, a trade is executed and both orders are updated. Price-time priority means orders at the same price are matched in the order they were received. The matching engine must process these operations atomically and deterministically — no two orders should produce a different outcome depending on processing order.

What custody model should we use?

For a new exchange: MPC-based custody (Fireblocks or in-house) combined with cold storage tiering. MPC distributes signing authority across multiple parties with no single private key ever fully assembled — compromise of one party does not compromise funds. Cold storage holds the majority of user assets with withdrawal requiring multi-party approval and a time delay. Hot wallet holds only the minimum needed for real-time withdrawals with strict velocity limits. Exchange-managed single-key hot wallets are not an acceptable custody model for any platform holding significant user funds.

How do we handle liquidity before we have users?

A CLOB exchange with no liquidity has wide spreads and no trading activity — a self-reinforcing problem. Solutions: negotiate with market makers before launch (they provide liquidity in exchange for fee rebates or token allocations), use AMM backstop liquidity for guaranteed depth, launch with a curated set of trading pairs rather than many thin markets, and consider a soft launch with beta users before public marketing. The liquidity strategy must be part of the architecture conversation — market maker API capabilities, fee tier design and spread parameters all affect market maker economics.

What compliance infrastructure does an exchange need?

At minimum: KYC (identity verification with document checking), AML (ongoing transaction monitoring against known patterns), sanctions screening (OFAC, UN, EU lists at onboarding and continuously), and transaction reporting for suspicious activity. In most jurisdictions this also requires a licensed compliance officer, a compliance policy document and record retention. The specific requirements depend on the jurisdictions you operate in and the assets you support. We build the technical infrastructure; you will need qualified legal counsel for the regulatory structure.

How do we prevent front-running?

Front-running on a CEX is primarily an information asymmetry problem — can privileged parties see order flow before execution? Controls: strict access separation between matching engine operators and trading accounts, audit logging of all order flow access, randomised execution ordering within price-time priority windows and regular independent audit of order flow handling. On hybrid or DEX models with on-chain components, commit-reveal schemes, private mempools (Flashbots Protect) or intent-based routing (CoW Protocol, 1inch Fusion) prevent mempool front-running architecturally.

What does exchange infrastructure cost to operate?

A production exchange with multi-region deployment, high-availability matching engine, custody infrastructure and compliance tooling typically costs $15,000–50,000/month in cloud infrastructure at early stage. Compliance tooling (KYC provider, AML monitoring) adds $2,000–10,000/month depending on volume. MPC custody providers like Fireblocks charge per vault and per transaction. The operational cost model should inform the fee structure design — most exchanges need $500K–2M in annualised trading volume to cover operational costs at typical fee rates.

Can we launch in multiple jurisdictions?

Yes, but each jurisdiction adds compliance requirements, KYC/AML obligations and potentially product restrictions (e.g., US users cannot access certain derivatives products). Multi-jurisdiction compliance requires geo-based access control, jurisdiction-specific KYC workflows and transaction reporting to each applicable regulator. We build the technical infrastructure to support multi-jurisdiction compliance — but each jurisdiction requires qualified legal counsel to confirm the applicable regulatory requirements. Launch in one jurisdiction with a clean compliance model before expanding.

How do we handle market manipulation?

Wash trading, spoofing and layering are active threats against exchange market integrity. Technical controls: order-to-trade ratio limits (accounts placing many orders without executing are likely spoofing), cancel rate monitoring, anomaly detection on account-level order patterns, and account relationship detection to identify entities running wash trade rings. These controls require ongoing tuning as manipulation patterns evolve. Institutional credibility requires demonstrable market surveillance — it is not optional for any exchange seeking regulatory licensing or institutional liquidity provider relationships.

What is the realistic build timeline for an exchange?

A production spot exchange with matching engine, custody, KYC/AML, market data, trading frontend and admin infrastructure: 20–32 weeks from architecture sign-off to soft launch. Adding derivatives, margin trading or complex order types extends this by 8–16 weeks. DEX or hybrid architecture adds 4–8 weeks for smart contract development and audit. Compliance infrastructure and regulatory approval processes run on a separate timeline that depends entirely on jurisdiction and licensing requirements. We deliver in milestone-based sprints with a soft launch to invited users before public release.