The platform
The Integrate platform is a production-proven, event-driven framework for capital markets — continuously evolved over twenty years of deployment across exchanges, brokers, and regulators. It can serve as a complete solution stack or as a targeted component within an existing architecture. The framework imposes no preconceived solution; it is shaped entirely by the requirements of the engagement.
Platform Overview
Integrate is a purpose-built, event-driven platform for capital markets — designed from the ground up for the stability, resilience, and low-latency performance that trading and regulatory environments demand.
The architecture is designed for rapid application development and deployment without large specialist teams. Applications are purpose-designed per engagement — the framework provides the runtime, component model, and business logic layer.
Integration with internal systems — messaging backbones, trading systems, and matching engines — as well as external connectivity to clients, vendors, and regulators for order entry, market data distribution, and regulatory reporting, is achieved through a rich adapter framework with native services for logging, threading, and configuration. Proprietary and industry-standard protocols not available out of the box can be onboarded via the adapter API, ensuring the platform connects to whatever the environment demands.
Applications are built using a structured development tool for defining run-time behaviour in terms of system entry and exit points — integration adapters for connecting to upstream and downstream systems — internal business logic, and configuration. This design-first approach means applications can be assembled, validated, and deployed rapidly without large development teams, and modified incrementally as requirements evolve.
The framework is protocol agnostic and imposes no prescribed processing model — applications can be designed as stateless or stateful depending on requirements, accommodating everything from simple integration workflows to complex, multi-stage processing pipelines.
Where ultra-low latency is required, the framework provides a direct escape hatch: critical processing paths can be implemented as custom Java components that bypass the configuration layer entirely, delivering native performance without abstraction overhead.
An adapter is a structured component that conforms to a well-defined API, providing the integration surface between the platform and external systems, protocols, and data feeds. The framework is protocol agnostic — adapters exist for industry-standard protocols as well as proprietary and vendor-specific feeds, and new protocols can be onboarded via the same API without disrupting existing production workflows.
Each adapter is independently deployable and versioned. Protocol-specific parameters — FIX session identifiers, Refinitiv service names, and equivalents for any supported protocol — are managed as first-class configuration within the same framework, with no separate configuration system required.
The adapter API exposes a rich set of native platform services that adapters can leverage directly:
The adapter framework includes built-in unit testing support as part of the standard development lifecycle. Beyond that, the framework itself is commonly used to build simulators for end-to-end integration testing — particularly where gaps exist in the broader solution stack due to unavailable vendor components or incomplete environments.
Framework-based simulators can be prototyped and deployed rapidly, and are not limited to basic functional testing. The same approach supports performance and throughput validation at production scale, as well as deliberate failure and recovery scenario testing — capabilities that purpose-built third-party testing tools often cannot match in demanding capital markets environments.
The framework provides a layered extensibility model that allows applications to be extended at whatever level the requirement demands — from lightweight inline scripting to deep framework integration.
At the workflow level, JVM-compatible scripting languages can be embedded directly within the standard processing pipeline for inline business logic and transformation. Discrete Java components can be introduced at any point in the workflow configuration sequence, and external libraries are automatically loaded at startup by placing them in the designated lib directory — no additional configuration required.
For deeper integration, a module extension mechanism provides direct access to internal framework APIs, beyond what is available through the standard component model. A global namespace, defined through the startup configuration, allows custom methods, variables, and state to be declared once and made available across the entire runtime — supporting shared logic and cross-cutting concerns without duplicating configuration.