Architecture Map

Purpose

This document helps readers navigate the architecture documentation.

It explains which document is authoritative for which concern and provides reading paths for common questions. It does not carry primary definitions — those belong in the documents it points to.

For a brief semantic introduction to each core concept, see Concepts Overview.

Document map

Foundational semantics — read first

Question	Document
What do all core terms mean?	Terminology
What is an Event? What kinds exist?	Event Model
What is the Event Stream and Processing Order?	Event Model · Time Model
What is Configuration and why does it matter?	Terminology: Configuration
What is State and how is it derived?	State Model
What are the three State domains? Is Queue a domain?	State Model
What is Processing Order vs Event Time?	Time Model

Core runtime model

Question	Document
What are the logical components and their responsibilities?	Logical Architecture
What is the step-by-step runtime sequence?	System Flows
How does an Intent move from Strategy to Venue?	Intent Pipeline
What is the system's top-level structure and layer organization?	Architecture Overview

Lifecycle semantics

Question	Document
What is an Intent? What lifecycle stages does it pass through?	Intent Lifecycle
When does an Order begin? What states can it reach?	Order Lifecycle
How are concurrent Intents for the same order key reconciled?	Intent Dominance

Execution Control and Queue

Question	Document
What is the Queue? Is it a source of truth?	Queue Semantics
How does Queue Processing select work for dispatch?	Queue Processing
What is Execution Control and how does it differ from Risk?	Terminology: Execution Control · Logical Architecture

Determinism and correctness

Question	Document
What does determinism mean in this system? What breaks it?	Determinism Model
What are the non-negotiable system invariants?	Invariants

Infrastructure and deployment

Question	Document
How are the system's stacks organized?	Architecture Overview
How does Backtesting relate to Live at the semantic level?	Architecture Overview
How is the system deployed?	Physical Architecture

Runtime decision flow

Trading decisions inside the Core Runtime follow a deterministic event-driven chain:

flowchart TB
    E["Event\n(Processing Order)"]
    SD["State derivation\nf(Event Stream, Configuration)"]
    ST["Strategy\nreads State"]
    IN["Intent\n(command)"]
    RK["Risk Engine\nallowed / denied"]
    QP["Queue + Queue Processing\nExecution Control"]
    VA["Venue Adapter"]
    VN["Venue"]

    E --> SD
    SD --> ST
    ST --> IN
    IN --> RK
    RK -->|"allowed"| QP
    QP --> VA
    VA --> VN
    VN -->|"Execution Events"| E

Key points for navigation:

Events → State: Every State transition is caused by an Event. State is f(Event Stream, Configuration). → Event Model, State Model
Strategy: Reads derived State projections; emits Intents (ephemeral commands, not Events, not Orders). → Logical Architecture
Risk Engine: Decides policy admissibility only (allowed / denied). Does not schedule, rate-limit, or gate. → Logical Architecture
Queue + Queue Processing: Implement Execution Control only — schedule and dispatch allowed work as part of deterministic Event processing; no separate runtime tick; Queue is derived substate, not a source of truth. → Queue Semantics, Queue Processing
Orders: Begin at submission. Queue residency and Risk acceptance are not Order states. → Order Lifecycle
Venue feedback: Returns as Execution Events, advancing already-existing Orders. → Event Model, Order Lifecycle

For the full step-by-step sequence, see System Flows.

System topology

The System is organized into three infrastructure layers:

flowchart TB
    marketData["Market"]
    marketLive["Market"]

    subgraph dataPlatform["Data Platform"]
        recording["Data Recording Stack"]
        quality["Data Quality Stack"]
        storage["Data Storage Stack"]
        recording --> quality
        quality --> storage
    end

    subgraph coreRuntime["Core Runtime"]
        backtesting["Backtesting Stack"]
        live["Live Stack"]
    end

    subgraph analysisMonitoring["Analysis and Monitoring"]
        analysis["Analysis Stack"]
        monitoring["Monitoring Stack"]
    end

    marketData --> recording
    storage <--> backtesting
    storage <--> live
    storage --> analysis
    backtesting --> monitoring
    live --> monitoring
    live <--> marketLive

Layer	Role
Data Platform	Collects, validates, and stores canonical datasets
Core Runtime	Executes trading logic deterministically (Backtesting and Live)
Analysis and Monitoring	Evaluates results and observes operational health

Detailed Stack descriptions: Architecture Overview · Stacks

Backtesting and Live

Backtesting and Live are two implementations of the same Core Runtime semantics.

Both apply State = f(Event Stream, Configuration), the same Intent → Risk → Execution Control → Dispatch chain, and the same Order lifecycle beginning at submission.

Infrastructure differs; semantics do not:

Aspect	Backtesting	Live
Market data	Historical datasets	Live Venue feeds
Venue	Simulated	Real
Operation mode	Batch experiments	Continuous

→ Architecture Overview · Backtesting Stack · Live Stack