Real-Time Integration

Real-time integration enables systems to exchange data with minimal latency, providing immediate updates when data changes occur.

Real-Time Integration Overview

Unlike batch processes or scheduled synchronization, real-time integration focuses on:

• Immediate data exchange (milliseconds to seconds)
• Event-driven interactions
• Live user experiences
• Bi-directional data flow
• Responsive applications

When to Use Real-Time Integration

Real-time integration is ideal when:

• Users need immediate feedback
• Data has a short relevance window
• Collaboration between users is required
• Processes depend on current state information
• Timely decision-making is critical

Real-Time Integration Approaches

WebSockets

WebSockets provide a persistent connection between client and server:

• Full-duplex: Data flows in both directions simultaneously
• Persistent connection: Maintains a single TCP connection
• Low latency: Minimal overhead after initial handshake
• Browser support: Native in modern browsers
• FileMaker integration: Requires custom web viewer or plugin

HTTP Long Polling

Long polling simulates real-time through extended HTTP requests:

• Compatibility: Works with standard HTTP tools in FileMaker
• Simulated push: Server holds request open until data is available
• Implementation: Can be implemented with Insert From URL
• Drawbacks: Higher overhead than WebSockets

Server-Sent Events (SSE)

One-way communication channel from server to client:

• Simple: Built on standard HTTP
• Efficient: Designed for server-to-client streaming
• Auto-reconnect: Built-in reconnection handling
• FileMaker limitation: Not directly supported in FileMaker

Short Polling

Regular, frequent requests to check for updates.

Adaptive Polling

Intelligent polling that changes frequency based on activity.

FileMaker Implementation Approaches

Plugin-Based Solutions

• MBS Plugin: Provides WebSocket client functionality

Web Viewer Integration

Leverage web viewers to handle real-time communication:

1. Create a web viewer with custom HTML/JavaScript
2. Use JavaScript for WebSocket or SSE connections
3. Bridge data to FileMaker using the Perform Script JavaScript function
4. Implement a FileMaker script to receive and process data

Server-Side Component

Implement a middleware layer that bridges your real-time service and FileMaker:

1. Create a server application (Node.js, Python, etc.) that manages WebSocket connections
2. Configure the server to interact with FileMaker via the Data API
3. Have FileMaker regularly check for updates via the server application

Claris Connect Implementation

Claris Connect can be used to enable real-time patterns:

• Webhooks: Configure webhooks to trigger flows when events occur
• Polling Schedules: Set up frequent polling schedules to check for changes
• Data Transformation: Process and transform data in real-time
• Multi-step Flows: Coordinate complex real-time workflows

Example approach:

1. Create a webhook receiver in Claris Connect
2. Configure FileMaker to trigger the webhook when data changes
3. Use Claris Connect to process the webhook and update other systems
4. Configure notification actions to alert users of changes

Common Real-Time Integration Scenarios

Chat and Messaging

• Customer support chat: Live interaction with customers
• Team collaboration: Internal messaging between staff
• Status updates: System notifications and alerts

Live Dashboard Updates

• Sales statistics: Real-time revenue and conversion tracking
• Production metrics: Live manufacturing or service delivery stats
• System monitoring: Server health and performance metrics

Collaborative Editing

• Document collaboration: Multiple users editing the same record
• Approval workflows: Live status updates during review processes
• Real-time validation: Immediate feedback on data entry

Advantages and Challenges

Advantages

• Immediate data visibility
• Enhanced user experience
• Timely process execution
• Reduced decision latency
• Better collaboration

Challenges

• Higher system complexity
• Increased resource consumption
• Connection management overhead
• Error handling complexity
• Potential consistency issues

Best Practices

1. Implement heartbeats: Regular signals to confirm connections are alive
2. Design for reconnection: Handle connection drops gracefully
3. Consider state synchronization: Methods to recover state after disconnection
4. Balance frequency and load: Find the right polling frequency for your needs
5. Use message queues: Buffer real-time messages during high volume periods
6. Implement proper error handling: Handle disconnects, timeouts, and failures
7. Monitor connection health: Track metrics on real-time connections