Keep up to date
Architecture

Tbricks by Itiviti architecture

Financial markets are transformative in nature, and successful firms must constantly re-evaluate and adapt. With its easy-to-use interface, solid performance, powerful built-in apps and tools to build your own, Tbricks by Itiviti is a game-changer that helps redefine what a trading system can be.

Powerful system core and apps

With a user-friendly interface, solid performance and powerful built-in apps, Tbricks by Itiviti is a game-changer that helps redefine trading technology.

Tbricks is entirely server-based and is realized as a set of specialized services. Each service performs a single task extremely well — whether it’s running trading apps or receiving and processing market data — and is highly optimized to perform it with utmost speed and efficiency. The services are deployed in a distributed cluster configuration to provide unparalleled scalability and are well suited for colocation.

All trading functionality and business logic is provided as apps, just as you are used to functionality being provided in a modern smartphone. As each app can be updated independently from each other, making changes is safe and fast. The clean separation between the Tbricks core system and the apps running on top of it, ensures that apps can be updated with a separate time schedule from when the core Tbricks system is updated, setting a new gold standard for how functionality can be delivered quickly to the business.

The development environment and rich Software Development Kit (SDK) used to develop the built-in apps are also available to build custom new apps or can be used to extend and customize the built-in ones independently, as we provide you with source code to all the built-in apps. A normalized data model unifies the interaction with electronic exchanges, making it easy to redeploy a successful trading app on multiple markets with a minimum of effort.

The right service for the job

Services

The specialization of services allows a user to perform queries with exceptional performance – for orders or trades, for instance — while insulating live trading operations from any potential performance impact, as would inevitably affect a simpler monolithic solution.

For example, when a user opens an order list to display orders matching a specific filter criterion (“show me all my filled BMW buy orders from yesterday”), the request would be handled by the Order Persistence service rather than by the Trading service. This clean separation of long-term persistence from market access services ensures that common operations, such as ad-hoc queries or starting a front-end application during trading, won’t affect the operation of performance critical services, such as the Trading service, at all.

Server-based and enterprise ready

The server-based architecture makes Tbricks exceptionally scalable, starting with a single node in a single location for an initial deployment, up to multiple nodes per location, in many locations, for more complex distributed set-ups. The advantage of being completely server-based is clear: whenever server resources are added to the installation, all users immediately benefit from a faster system. There is no need for frequent and expensive upgrades of end-user desktop machines to achieve the best possible performance.

Tbricks is well suited for team trading and is built for true enterprise installations, with built-in audit trail, a Role-Based Access Control permission model, Active Directory user authentication and easy-to-use administration tools featuring full support for managing a distributed cluster. Additionally, all data can be easily be shared, providing users the ability to see the exact same screen regardless of which computer that was used for logging into the system, as no data is stored locally.

Develop custom apps

A major roadblock to innovation is the massive maintenance backlog that burdens most IT departments with legacy technology. Tbricks architecture is the only trading platform that includes change-ready apps.

Tbricks allows you to build custom apps that meet your specific requirements. It is possible to build trading apps, customized pricing or volatility models, reports or accessory apps that are optimized to enhance your workflow. The rich framework used to develop custom apps, is exactly the same framework that Tbricks uses to create the built-in apps. This ensures that any custom apps you build, are truly first-class citizens and can run with full native performance.

All the built-in apps are provided in source code, allowing you to use them as a starting point for any custom development that you want to do — you can even locally branch them and create variations of the built-in apps if you so desire. We believe that the business logic used for trading and pricing should be fully transparent and not hidden in a black box, and there is no better way to do that than to provide the actual source code.

You can use standard development environments such as Eclipse, Visual Studio or Netbeans for development. A robust set of tools supports your app development, including on-the-fly updates of updated apps in a testing environment, as well as performance analysis tools that help you analyze your runtime performance without resorting to logging that may impact performance.

Liquidity fragmentation

The reality of today’s financial markets is that liquidity for a given instrument often is spread over many markets, which creates several challenges. One of them is the management and display of large numbers of multi-listed instruments in an efficient and user-friendly way; another is to ensure that positions are maintained in a single entity rather than split out by market.

The Tbricks instrument and position models handle this complex reality by design, rather than as an afterthought. This is reflected throughout the system with its full support for order book aggregation, unified risk management for multi-listed instruments as well as built-in smart order routing to easily benefit from the distributed liquidity.

The Tbricks instrument model is built for instruments that are multi-listed. All instruments can be listed on any number of market data and trading destinations simultaneously. Trades and positions are kept for this single instrument, but can be easily broken down by market if desired. Market data, including the full order book, is automatically aggregated in the Tbricks front-end, and can be broken down by market as needed. Strategies can look at all markets simultaneously and choose to send orders to the market that is cheapest or fastest — or even to sweep multiple markets — depending on your strategy. Tbricks will automatically create multi-listed instruments when possible as part of the download of instrument reference data.

Co-location

Trading firms aspiring to achieve optimal performance invariably use facilities located in proximity to, or co-located at the exchange, to minimize network latency. This can be a challenge when it comes to interacting with trading strategies running at multiple locations simultaneously. From a functional perspective, this can make visualization or aggregation of data difficult. Network bandwidth constraints to the remote location can also affect overall responsiveness.

Tbricks’ distributed cluster architecture was designed for co-location in multiple concurrent locations from its inception. The services that run in a specific co-location facility are logically grouped together as a subsystem, which represents their geographical location. A user can optimize the latency characteristics for a given trading strategy for a specific market simply by choosing which subsystem it should run in. Regardless of where the trading strategies are running, they will all be displayed in a consolidated manner in the front-end.

Turn up the signal, wipe out the noise

The easy-to-use Tbricks front-end provides a fast and efficient interface that scales seamlessly with the number of screens that you have available. Unlike what most users are used to, it provides a completely unified and consolidated view of all the markets you are trading on, on a single screen. This avoids the need to change viewing context or even having to add additional screens just to trade on a new market.

The Tbricks front-end has extensive support for customization, including fully dynamic lists showing opportunities or other items of interest, custom highlighting support and different kinds of graphical representations such as tree-maps for efficient visualization of large data sets. Overall, this allows you to efficiently turn information into knowledge, allowing you to focus on what is truly important.

Designed to be custom-designed

The underlying data model used for setting parameters is easily extensible with new properties, both simple fields that are persisted as well as derived properties written using the Lua scripting language. The underlying data model supports a sophisticated grouping of parameters with multiple hierarchical groups, providing an easy way to set common parameter values for a large set of instruments that share a common attribute, such as having the same product type, underlying, currency or even custom groups. A rich model of separate parameters contexts and configurable lookup conventions, allows disparate user groups to optionally share certain base data, and easily allows different trading desks or e.g. risk functions to have their own values for key parameters such as volatility.

All the built-in apps are provided in source code form, to allow you to use them as a basis for your own customized versions if desired — this is a perfect starting point for experimentation with new trading apps if desired. It is also possible to fine-tune the user interface using simple drag and drop editing tools, so you can make that order panel look just as you want it. The shortcuts used throughout is also customizable, including mouse actions, keyboard shortcuts as well as defining custom actions that should be performed, including macro actions.

Fast and efficient presentation

Although beautiful, the Tbricks front-end has qualities that run more than skin deep. It is extremely customizable and allows you to fine-tune the presentation of your information with great precision. Live and dynamic lists based on custom filters that only show data that fulfills predefined conditions is standard.

You can freely script derived parameterized values using the Lua scripting language and use this as part of such dynamic lists or for sorting in a data grid. Custom parameters and user preferences are quickly added to the system and can be used both in scripts and for list filtering and are true native parameters of the system, leveraging on the exact same infrastructure as any built-in parameters use.

The instrument parameter model allows for a fast and flexible way to set parameters for multiple instruments at once by using a powerful grouping mechanism, which includes parameter inheritance hierarchies, parameter contexts, and shared as well as user-specific parameters.

You can fine-tune the user interface that should be used by both custom and built-in apps, to make sure that your apps look just as you want them to. The front-end is built to handle multiple screen layouts and configurations in an efficient manner, and allows you to easily swap between different workspaces. The extensive support for actions and shortcuts in the system makes sure that you can perform input and actions in the most efficient manner possible, adopting the front-end to your preferred workflow.

Subscribe to our newsletter

Keep updated about Itiviti.