Unique scenario? Why using Linedata’s APIs makes sense

In a competitive trading landscape, managing order flow with speed, accuracy, and security is essential. And an order management system (OMS) enables firms to manage portfolios and trade at scale. But as we mentioned in the first API blog in our series, it can be difficult for the applications within a firm’s digital ecosystem to communicate with each other in an accurate and timely manner.

That’s why APIs (Application Programming Interfaces) are so important. When APIs are effectively engineered, they allow for seamless integration between an OMS and the dozens of other applications within an ecosystem.

Let’s look at Linedata Longview order management system (OMS). Firms use the system to manage their end-to-end order workflow. The OMS helps users run regulatory and compliance checks, analyze trades, research the impact on portfolios, and execute decisions based on the best data. And APIs enable all of that data transfer between applications.

So why might a firm be hesitant to fully integrate with Longview using Linedata’s API gateway?

Transition periods are difficult for firms

In the fast-moving world of financial services, complex scenarios arise that complicate the digital ecosystem. As such, we occasionally encounter clients that are acting as subadvisor or transitioning a portion of an existing book of business to Linedata.

These firms sometimes need to maintain their current integrations as a temporary bridge to a full integration, as opposed to immediately, fully adopting Linedata Longview software. This approach requires integrations to be built between the OMS and other third-party order management systems. And this undertaking is no simple task.

Why third-party OMS integrations are a resource drain

These integrations are often expensive and require large-scale development efforts. Both the firm and Linedata must engage in a discovery phase to identify the functional and non-functional requirements for the integration before an optimal solution can be designed and implemented.

Also, these integrations are custom-built to clients’ specific needs. So, they are not easily scalable, and they may require further development following the next application update or upgrade. A few other drawbacks of bespoke integrations include:

• Considerable operational overhead to maintain
• The requirement to address exceptions with manual intervention
• Integration upgrades required every time the client upgrades to a newer version

Because these custom integrations lack scalability, clients who utilize them are often limited in how quickly they can onboard new business or expand the coverage of supported asset types. These opportunity costs add up, and they can hurt the firm in both the short and long term.

What about firms that onboard Linedata Longview but still maintain homegrown solutions?

Solution to the homegrown customer web portal problem

We also encounter Linedata Longview OMS clients that come to us with existing homegrown systems. For example, a firm may have a homegrown customer web portal where their customers can log in to see their start of day and end of day account balances and positions. By deploying Longview without using our API gateway, the firm creates extra development work and a less stable integration.

However, when the firm utilizes Linedata’s APIs, the integration is simplified. Using the APIs allows the firm to pull those account balances and positions out of Linedata Longview in one of two ways:

1. Synchronously, calling the API at the request time to get that data
2. Listening to events and building that data within their system, then displaying that to the customer

With Linedata’s API approach, previously complicated, patchwork integrations are simplified. And the integrations are robust and long-lasting.

Why is using Linedata’s API so valuable to customers?

Without using standard APIs such as JSON and REST, these aforementioned scenarios demand tightly coupled, database-level integrations. This type of integration requires writing queries directly against the database and inserting data directly into tables. The resulting integrations are:

• Brittle
• Difficult to test
• Likely to break after updates

But with a clean, versioned, backward-compatible API, these integrations can be loosely coupled and confidently tested.

Why is it important for integrations to be loosely coupled?

When two applications are tightly coupled, a change to one application has a huge impact on how the other application operates. So, if you change one system, it essentially “breaks” the other connected system. There’s a lack of flexibility.

But with a loosely coupled integration, that same danger isn’t present. The two systems are still coupled — in that they are specifically designed to be aware of and talk to each other — but a change in the interface of one system has little effect on the other.

That’s why Linedata’s APIs are engineered to be loosely coupled. When using our API, clients can upgrade Linedata Longview OMS without breaking the integration between Longview and their own system. So instead of being forced to repair broken integrations — as you would with traditional, tightly coupled engineering — you can move forward with your updated trading platform quickly and efficiently.

A loosely coupled API gives you integrations that are:

• Flexible
• Reliable
• Re-usable

Make Linedata Longview OMS integration easy with loosely coupled APIs

While companies have their reasons for retaining existing integration structures and non-standardized processes and APIs, our API gateway creates a simple, flexible integration that makes using our leading order management system easier than ever.

To find out how your firm can benefit from our flexible approach to integrations utilizing modern APIs, talk to your Linedata relationship manager today or contact us here.

About the author, Jason Penniman

Jason Penniman: Geek, teacher, technologist, author, and blogger with his head in the Cloud, Jason is also platform architect for Linedata Asset Management. For over 25 years he’s been building scalable enterprise solutions and integrations, and helping companies improve through cultivating people, process, and technology. Allons-y!