Architecture

Likely is built as a distributed system with specialized services that work together to process bundles, execute trades, and deliver real-time updates.

System Flow

Traders
   ↓
Ingress (HTTP API)
   ↓
Sequencer (Timestamps & Orders Events)
   ↓
Matcher (Processes Auctions)
   ↓
Dispatcher (Routes Results)
   ↓
WebSocket (Real-Time Updates)
   ↓
Traders

Core Services

Service	Purpose	What It Does
Ingress	API Gateway	Receives bundle submissions, validates requests, authenticates users
Sequencer	Event Ordering	Assigns timestamps to all events, detects auction boundaries (every 500ms)
Matcher	Execution Engine	Processes auctions, executes bundles, manages orderbooks and user state
Dispatcher	Event Router	Routes execution results to appropriate users, filters private vs public data
WebSocket	Real-Time Updates	Streams updates to connected clients (bundle results, orderbook changes, balances)

Data Layer

NATS JetStream:

Event streaming backbone
Guarantees event ordering
Enables replay for recovery
Scales horizontally

Redis:

Fast user state cache
Sub-millisecond access
Recent trader data

QuestDB:

Time-series analytics
Historical trade data
User balance history
Market statistics

Snapshots:

Periodic state backups
Fast recovery
Every 5 seconds

How a Bundle Flows Through the System

1. Submission (t=0ms)

You → Ingress: Submit bundle via HTTP
Ingress: Validates structure, checks auth
Ingress → Sequencer: Forward to event stream

2. Sequencing (t=5ms)

Sequencer: Assigns timestamp and sequence number
Sequencer: Detects current auction window
Sequencer → Matcher: Publish to event stream

3. Queuing (t=10ms)

Matcher: Receives your bundle
Matcher: Adds to auction priority queue
Matcher → You: "Bundle accepted" confirmation

4. Auction Close (t=500ms)

Sequencer: Detects 500ms elapsed
Sequencer → Matcher: Close auction event
Matcher: Processes queue by priority
Matcher: Executes top bundles
Matcher: Distributes tips to makers
Matcher → Dispatcher: Fanout results

5. Delivery (t=505ms)

Dispatcher: Routes to your user topic
WebSocket: Streams result to you
You: Receive execution confirmation + balance updates

Total latency: 5-505ms depending on when you submit within the auction window.

Why This Architecture?

Event-driven design:

Everything is an event (auditable, replayable)
Services can scale independently
Natural disaster recovery via event replay

Batch processing:

Fair competition (no speed advantage)
Efficient resource usage
Predictable latency

Separation of concerns:

Each service has one job
Easy to understand and maintain
Can optimize independently

Auction Timing

The Sequencer is the heartbeat of Likely:

Detects every 500ms boundary
Emits AuctionOpen events
Emits AuctionClose events
Ensures deterministic batch IDs

This creates the rhythm: submit → wait → execute → repeat.

Privacy by Design

Bundle privacy:

Bundles don’t expose trader identity
Only you see your bundle details
Market sees aggregated orderbook

Selective routing:

Dispatcher filters events by user
Private data goes only to you
Public data (orderbooks, auction state) broadcast to all

This is a key differentiator vs platforms like Polymarket where trader profiles are public.

Next Steps

Understand Matching Engine execution
Learn about Batch Auctions timing
Explore OrderBook matching

Getting Started

Platform Core

Trading Mechanics

Financial Engine

Ecosystem

System Flow

Core Services

Data Layer

How a Bundle Flows Through the System

Why This Architecture?

Auction Timing

Privacy by Design

Next Steps

​System Flow

​Core Services

​Data Layer

​How a Bundle Flows Through the System

​Why This Architecture?

​Auction Timing

​Privacy by Design

​Next Steps

System Flow

Core Services

Data Layer

How a Bundle Flows Through the System

Why This Architecture?

Auction Timing

Privacy by Design

Next Steps