Introduction to Finsemble

Finsemble is a desktop integration platform, connecting all of your applications together—modern or legacy, in-house or third-party. This is done with little to no development work; Finsemble cuts development time to integrate separate applications from weeks or months to hours or days. The end result of these integration efforts is a cohesive smart desktop consisting of separate but interconnecting applications.

Finsemble provides two types of integration. The first type is visual integration. Visual integration creates form that facilitates function. All applications launched by Finsemble share an aesthetic. This look and feel is defined by your organization through easy white labeling. Each window can participate in a range of thoroughly considered, mature UX features. Windows can snap, dock, group, tile, and tab. Windows launched by Finsemble are persistent between sessions, reloading in the same position and with the same content. These capabilities are available for all applications out of the box, with zero coding.

This level of integration is important, but it's not enough. Finsemble also provides a deeper level of synthesis with logical integration. Applications communicate and work together no matter the language they're written in—even if you don't have control over the source code.

Logical integration allows you to create custom workflows. Workflows occur when Finsemble facilitates interoperation between two applications. For example, a user might share a ChartIQ chart with a client—with all data layers and annotations—through Symphony chat. Workflows can also occur when developer-created rules trigger events. For example, when a user shares a ChartIQ chart with a client over Symphony, a CRM like Salesforce can automatically log this activity for tracking purposes.

  • A good place to orient yourself to all the reasons we built Finsemble is the Finsemble White Paper.

  • If you're a developer who wants to get their hands on the code, check out the Finsemble seed project.

  • If you're a developer who wants a better insight into our architecture, take a glance at our tutorials—check out the Architectural Overview as a starting point.

Have questions? Reach out to

The User Experience

Finsemble unifies the desktop experience. It comes with production-ready, fully customizable modular UI.

App Suites

Group applications together to launch and maximize them as a unit

Conceptually similar apps may be launched at the same time. Additionally, with a click, this group can "hyperfocus," which minimizes everything that isn't a part of the group.

Drag and Drop Data Sharing

Selectively drag-and-drop data between components

Users can instantly transfer data between windows with a simple drag and drop action. For example, Salesforce contact information could be dragged into a Symphony chat.


Leverage keyboard shortcuts across all of the apps in your workspace without fuss

It's hard to use keyboard shortcuts with web apps because they only capture keystrokes when the browser window has focus. Finsemble solves this issue by capturing keystrokes globally, so hotkeys can be used no matter what.


Link components by symbol, account, or other data types

Multiple components can synchronize on a shared context. For example, linking applications together by stock symbol allows all applications to update their data automatically when the stock being viewed changes. The Linker uses a powerful but simple paradigm of colored "channels" to assign groups of components to participate in synchronization.


Workspace and component catalog awareness

Users have access to a single search box that can federate search requests across multiple back-end services and display the returned data in a single result set. Results are actionable, allowing an end user to click on the result to bring up the data. For instance, searching for "Apple" could bring up results for both market data and research—a click on the results will bring up that data in a corresponding component.

Window Management

Snap, dock, tab, and tile windows

Window management gives users power steering. Users can snap windows together, dock them into groups, tile them on top of each other, or tab them together.

Workspace Manager

Save and restore workspaces

Between sessions, Finsemble will save and relaunch correctly: all windows will be in the same position and all of their contents will be restored. End users can save multiple workspace layouts and easily switch between groups of applications for different tasks.

Technical Framework

Finsemble lets developers build an application using familiar web technologies and deploy a single code base to both the browser and the desktop.


Link to external authentication

Finsemble allows developers to add an authentication component to match their specific application's needs. This includes authenticating access to the entire application or authenticating access to specific components within the application. Finsemble is agnostic about the underlying authentication mechanism, but provides both a cohesive end user UX and framework abstraction. Further, some commonly used methods are supported out of the box, such as leveraging a user’s Windows login.

Central Logger

Diagnosis and debugging across multiple windows

Multi-window HTML5 application debugging is inherently fragmented; by default, single logical threads span multiple windows and must be tracked across multiple consoles. The Central Logger is a comprehensive dev tool that collates console messages across the entire Finsemble application.

Distributed Store

Scalability for complex applications

The Distributed Store reduces complexity by operating as a central repository. This reduces the number of connections that windows need to maintain. The Distributed Store hosts business logic which can be invoked by any window that it’s plugged into. This lets the store synchronize state across window boundaries. Multiple windows can share data, yet remain loosely coupled.

Dynamic Configuration

A single implementation allowing for multiple interfaces

Finsemble is designed to be inherently configurable because of one simple fact: you shouldn't build a huge system and hard code everything. Finsemble’s config can be assembled from multiple pieces, allowing you to organize your configuration logically, and Finsemble’s config is dynamic, so your application can adapt to entitlements, environments, and preferences.

Microservice Architecture

Architecture that allows scale

Finsemble is built on an extensible microservice architecture. These microservices provide an innovative infrastructure to support large applications in elegant ways. Microservices have a smaller memory footprint. Independent, cooperating parts guarantee stability as a single error doesn't crash the application.

Finsemble ships with a set of microservices that manage core features such as workspaces, storage, or docking. Firms and third-party vendors can also add their own microservices to encapsulate their own business logic.


Toast notifications for any component

Finsemble makes use of pop up (toast) notifications. Developers can leverage the API so that their components can create notifications. System messages and alerts are automatically routed through the notification system. Unlike operating system notifications, these notifications can be interactive, allowing end users to click on them to take action.

Presentation Components

Customizable UI Components

Most HTML5 UI toolkits are only meant for building single page applications. Finsemble provides UI components specific to the desktop paradigm and can be recombined and extended.


Communicate between components

For communications amongst microservices, components, or outside the container entirely, an event infrastructure provides high level protocols. At the center of this functionality is the Router API. Three abstractions are provided: Listen/Transmit, Query/Response, and SubPub. The Router API integrates directly with the Inter-Application Bus so that native applications can fully participate.


Save data to local or remote DB

Finsemble provides a persistence framework for connecting to external persistent storage (i.e., databases, tuple stores, etc.). Workspaces, windows state, and other Finsemble functions automatically use the persistence framework, eliminating the need for hand wiring. Components can use the storage API to save and restore state, ensuring that they are reconstituted appropriately during workspace reloads.

UI Controls

Atomic-level UI customization

Finsemble breaks UI components down into individual "controls": atomic-level UI building blocks which you can use to build your own componentry, or customize the built-in componentry. This goes far beyond simple theming and allows for true UI extensibility.

White Labeling

Easy theming

Finsemble comes with CSS files designed to simplify the process of white labeling the UI. The CSS has been carefully crafted with semantically meaningful variables. Developers can easily change font, color, and general appearance of interface sections by overriding any of a number of core variables. For deeper stylistic changes, Finsemble makes provisions for overriding any CSS style as part of the build configuration.

Client-Side Integration

Finsemble dramatically simplifies the process of building a single application from separate components.

Integrate Legacy Applications

Visual integration for native applications

Incorporate native applications into a Finsemble workspace using only configuration—no code changes or code control required. Once assimilated, native apps behave like any other Finsemble component, obeying layout, window management, and workspace management rules.

Integrate HTML5 Applications

Integrate HTML5 apps without code changes

Finsemble allows deep integration of web apps into your desktop experience. This can be done even when you do not have the ability to make code changes to the component. Critically, this allows a developer to “Finsembelize” a web-deployed application without changing how it is deployed to browsers. Finsemble-specific code is injected on-the-fly when the application is loaded onto the desktop. Workspace integration, symbol linking, and deep workflow integration (e.g., sharing data across the Router, pre-populating forms, automating tasks) are all possible without making code changes. This dramatically reduces integration times while reducing regression risk for stable assets.