Sync Engine

See It In Action

Watch the full demo to see bidirectional sync, OAuth management, conflict resolution, and the embeddable UI in action.

A Unique Position in the Market

The integration space has unified APIs (hosted, closed-source), ELT tools (one-way only), workflow automation (no sync state), and “open core” products with key features paywalled. A fully open-source, self-hosted, bidirectional sync platform with version vector conflict resolution doesn't exist elsewhere.

How We Compare

Full source code, self-hosted deployment, and true bidirectional sync — capabilities that don't exist together in any other product.

* Nango's free self-hosted version only includes the API proxy. Full sync engine requires Enterprise license. Airbyte is open source but designed for one-way ELT to data warehouses, not application-to-application sync.

Key Features

Embeddable Micro-Frontend UI

Ships with a complete React UI that you can embed directly into your application via Module Federation — or run standalone. Manage integrations, monitor sync jobs, and configure sync rules without building your own interface.

// Embed in your host application via Module Federation
import { IntegrationsProvider, MicroFrontend } from 'integrations/federation'

<IntegrationsProvider config={{
  apiBaseUrl: 'https://api.yourapp.com/integrations',
  getAuthToken: () => getToken(),
  onUnauthorized: () => redirectToLogin(),
}}>
  <MicroFrontend />
</IntegrationsProvider>

How Sync Works

Every record tracks three version numbers. Comparing them determines what needs to sync and in which direction.

internal_version  = 3   // Bumped when your system changes the record
external_version  = 2   // Bumped when external system changes the record
last_sync_version = 2   // Set to max(iv, ev) after successful sync

// Decision logic:
iv == ev == lsv  →  In sync (nothing to do)
iv > lsv         →  Outbound sync needed (push your changes)
ev > lsv         →  Inbound sync needed (pull their changes)
iv > lsv AND ev > lsv  →  Conflict (resolved by configured master)

Change Detection & Sync Triggers

Each sync rule specifies how changes are detected and when to act on them. Combine these for polling-only, event-driven, or hybrid sync workflows.

// Example: push-based sync with immediate trigger
{
  "entity_type": "vendor",
  "direction": "bidirectional",
  "enabled": true,
  "master_if_conflict": "external",
  "change_source": "push",
  "sync_trigger": "immediate"
}

API Overview

Adding a New Integration

The platform uses a Strategy + Adapter pattern. Each integration needs three things: an Adapter for API calls, a Strategy for sync logic, and Mappers for schema translation.

# 1. Adapter — handles OAuth and API calls
class XeroAdapter(IntegrationAdapterInterface):
    async def authenticate(code, redirect_uri) -> OAuthTokens
    async def fetch_records(entity_type, since) -> list[ExternalRecord]
    async def create_record(entity_type, data) -> external_id
    async def update_record(entity_type, external_id, data) -> success

# 2. Strategy — handles sync logic and entity ordering
class XeroSyncStrategy:
    async def sync_entity_inbound(entity_type, ...)
    async def sync_entity_outbound(entity_type, ...)
    async def sync_entity_bidirectional(entity_type, ...)
    def get_entity_order() -> list[str]

# 3. Mappers — bidirectional schema translation
def map_vendor_inbound(xero_data: dict) -> dict   # Xero → internal
def map_vendor_outbound(internal_data: dict) -> dict  # internal → Xero

# 4. Register in factory and strategy registry
adapter_factory.register("Xero", XeroAdapter)
register_sync_strategy("Xero", XeroSyncStrategy)

Configurable Sync Rules

Each entity type has its own sync rule. Configure direction, conflict resolution, and enable/disable per entity.

{
  "sync_rules": [
    {
      "entity_type": "vendor",
      "direction": "bidirectional",
      "enabled": true,
      "master_if_conflict": "external"
    },
    {
      "entity_type": "bill",
      "direction": "inbound",
      "enabled": true,
      "master_if_conflict": "external"
    },
    {
      "entity_type": "invoice",
      "direction": "outbound",
      "enabled": true,
      "master_if_conflict": "our_system"
    }
  ]
}

Technology Stack

Clean Architecture

Built with hexagonal architecture. Swap databases, cloud providers, queue backends, or encryption services without touching business logic.