Integrations Overview

Our Philosophy

At Kinetic Data, we believe that integrations shouldn’t be a bottleneck. Traditional software vendors often require customers to wait weeks or months for integration fixes or new connectors. Our philosophy flips that model. We empower customers to build, extend, and control their own integrations—on their timeline, not ours.

Our integrations provide an abstraction layer between external systems and their usage within the Kinetic Platform enabling customers to change what systems they're integrating with, without breaking their front-end's, Forms and Workflows.

Our framework is designed with openness, extensibility, and self-service at its core:

Customer-Driven: Customers can create and maintain their own integrations without relying on our engineering team.
API-First: Anything you can do through the Kinetic Platform’s UI can also be done programmatically via our open APIs.
Library of Extensible Integrations: We offer a collection of pre-built integrations that serve as launch points—ready to use out of the box or easy to extend for custom needs.

Types of Integrations

Our integration framework supports a range of use cases through multiple integration types. This flexibility ensures that customers can connect to virtually any system, regardless of architecture, protocol, or data format.

1. Connections & Operations

Use case: RESTful CRUD operations across external systems
Where used: Forms, workflows, and front-ends
How it works: These are low-code, in-platform integrations designed for speed and reusability. They make it easy to query, update, and manage data across systems that expose a REST interface.
Example: Creating a user in Active Directory or retrieving a ticket from ServiceNow.

2. Handlers

Use case: Custom business logic or system interactions within workflows
Where used: Workflows
How it works: Written in Ruby, Handlers are self-contained functions that define inputs and outputs through a standardized convention. Developers can build and test locally, then deploy to Kinetic for runtime use. Handlers support any protocol and allow for full customization.
Example: Authenticating via an OAuth flow, posting to a SOAP service, or transforming data for a legacy mainframe.

3. Bridges

Use case: Real-time data collection from external systems
Where used: Forms, front-ends
How it works: Developed in Java and deployed into the Kinetic Agent (our integration harness), Bridges enable Forms and front-end javascript to dynamically query data from external systems on the fly. Bridge adapters define the business logic and follow a standardized convention for querying and returning data back to the Kinetic Platform.
Example: Retrieving a list of users from Active Directory and presenting them in a Forms dropdown list.

4. Filestores

Use case: Streaming files and documents from external systems
Where used: Front-ends
How it works: Like Bridges, but optimized for handling documents and large files. They connect to file stores, retrieve documents, and present them inside the Kinetic Platform dynamically.
Example: Streaming PDFs from a document management system or displaying image files from a secure server.

5. WebAPIs

Use case: Triggering Kinetic workflows from external systems
Where used: Public-facing endpoints
How it works: WebAPIs expose dynamic REST endpoints that accept inbound requests from third-party applications. Incoming payloads are securely parsed and can initiate workflows within the platform. This allows external systems to seamlessly interact with Kinetic processes.
Example: A procurement system sending a purchase request to initiate a fulfillment workflow in Kinetic.

Built for Flexibility and Scale

The Kinetic Integration Framework is purpose-built for environments with complex ecosystems and ever-changing requirements. Whether you’re integrating with modern cloud tools or legacy systems, our approach ensures you can do so securely, quickly, and without unnecessary vendor dependencies.

Our commitment: You own your integration strategy—and we give you the tools to make it real.