Unified Market Data & Broker Integration for Global Systematic Futures Platform

Customer

Challenge

Unifying Disparate Data Worlds and Automating Execution

• Two data worlds, one model. Combine historical vendor data with live broker feeds/execution, maintaining symbol parity and handling multipliers/price magnifiers across instruments.
• Continuous futures construction. Implement roll calendars and carry for contract stitching; ensure clean monthtomonth transitions and deduplicate nontradingday artifacts.
• Execution to targets. Reconcile current vs target positions and rebalance via orders; provide fallbacks when venuespecific execution features are unavailable.
• Reliability & autonomy. Survive session disconnects, authentication friction, parameter/format changes, and keep the automation loop healthy on a dedicated node.

Solution

Iterative Delivery of a Unified Data & Execution Stack

Approach: Marsbridge staffed a compact squad - Tech Lead, Data Engineer, Execution Engineer, and DevOps - to deliver iteratively: data model → integrations → continuous futures & carry → execution orchestration → server automation & hardening.

Data architecture (Market Data ↔ Broker ↔ Database)

Unified schema. Designed normalized tables keyed by instrument metadata (ticker, contract month, trading class, currency, multiplier) so historical and live sources coexist cleanly. Import & normalization. Migrated flat files into the database; introduced quote multipliers/scalars (e.g., unitized commodity quotes) and FX quote factors for consistent series. Backfill logic. Added loaders for contract chains and spot tickers; legacy placeholders for historic contracts are promoted to live contracts when available. (All schema identifiers have been generalized.)

Continuous futures, carry & calendars

Roll calendars. Implemented expiry/roll calendars per product to compute month diffs and carry metrics consistently; resolved datatype/NaN edge cases that impact month calculations. Vendor parity & dedupe. Matched vendor historical levels closely while removing duplicate nontradingday values, improving historical quality for backtests.

Broker integration & execution to target

Native API sessions. Established stable broker sessions, position/PnL reads, and contractdetail caching in the database. Reconciliation routines align current vs target holdings and originate orders to close gaps. Order controls & fallbacks. Where venuespecific execution algorithms are not available, the platform uses planned orderslicing - splitting orders into smaller lots over the session. (Venue names and algorithm branding have been generalized.)

Server automation & resilience

Automation loop. Scheduled data refresh → signal compute → execution (interval configurable). Includes reconnect logic after drops and tuned “keep open” behavior. API hardening. Addressed fractionalsize/decimal changes and similar API evolutions by upgrading and adapting code paths; provided an FX compatibility mode for legacy configurations. (Version numbers elided.) Parallelism notes. Adopted conservative vectorization/controlled concurrency for price construction with stability safeguards. (Tooling brand names omitted.)

Technologies & tools

Process

Scope & repo setup. Asset coverage, code review, access control, decision to use native broker API. Schema & ingest. Model tables; migrate historical files; map local tickers to broker contracts; normalize units and FX factors. Continuous futures & carry. Implement roll calendars and carry; fix monthdiff edge cases; dedupe nontrading days. Broker integration. Contractdetail caching; price downloads; target vs current reconciliation; order inception; PnL reads; automation scaffold. Hardening & runtime. Compatibility patches for fractional sizes/decimals; reconnect/keepalive tuning; stabilityfirst parallelization. Execution refinements. Introduced planned slicing where advanced venue algos are unavailable. Production. Deployed to production; ongoing tweaks to reduce trading costs; platform supports future strategy research.

1. Scope & repo setup
2. Schema & ingest
3. Continuous futures & carry
4. Broker integration
5. Hardening & runtime
6. Execution refinements
7. Production

Results

• Unified data plane: Historical vendor data + live broker connectivity, normalized in Postgres with robust contract metadata.
• Continuous futures & carry: Calendaraware rolls with consistent carry metrics across product families.
• Execution engine: Target reconciliation and order inception; planned slicing where venue features are limited; PnL/position telemetry.
• Production automation: Headless system loop, hardened sessions, and resilience to API changes.

System deployed to production; client continues monitoring and costtuning, while researching additional strategies on the same platform. (No trade parameters disclosed.) Note: Performance metrics are strategydependent and outside this infrastructure scope; nothing herein is investment advice.