All Products Data & Config

Kiwi Fabric

Cross-database SQL federation and distributed-write orchestration. One SQL query across every data source you own — relational, NoSQL, REST, and SOAP — against live data, in real time, without moving anything.

Private Preview Data & Config Commercial
Get Notified at Launch Join as Design Partner
Kiwi Fabric — Data Federation
The Problem It Solves

Your Data Lives in Many Places. Your Queries Shouldn't Have To.

Modern enterprise data is fragmented by design. Orders in Postgres. ERP in SQL Server. Product catalogue in MongoDB. Logistics in a REST API. Finance in a legacy Oracle system. Running a report across all of them today means writing ETL pipelines, maintaining a data warehouse, and accepting that your data is always slightly stale.

Kiwi Fabric eliminates that entire layer. You write one SQL query. The platform fetches the relevant rows from each source in parallel, federates the results in memory, and returns a single unified result set — in real time, against live data.

For writes, the same principle applies. A single distributed saga transaction coordinates inserts, updates, and deletes across multiple databases with automatic compensation if any step fails. Kiwi Fabric is a conductor, not a musician — it orchestrates. The data stays in your systems. The platform never stores a copy.

Today's Reality
  • Cross-source reports require ETL pipelines and data warehouses
  • Warehoused data is always slightly stale — minutes to hours of lag
  • Distributed writes require custom saga implementations per project
  • Legacy systems require bespoke connectors and WSDL proxies
  • Every new source adds operational overhead and maintenance burden
With Kiwi Fabric
  • One SQL query, every source — no ETL, no warehouse
  • Live data, always — results fetched in real time in parallel
  • Distributed saga transactions with automatic compensation
  • REST and SOAP connected without WSDL proxies
  • One platform to register and query any source you add

Key Capabilities

Everything needed to federate reads and orchestrate writes across a heterogeneous data estate.

Cross-Source Federation

Write one SQL query that joins tables from different databases, APIs, and services. Sources are queried in parallel; predicates and projections are pushed down to each source for efficiency. The in-memory federation engine handles the final join, aggregation, and sorting.

  • Predicate and projection pushdown per source
  • Parallel source fetching — no sequential waterfall
  • Results always live — no ETL, no replication lag

Distributed Saga Transactions

Define a multi-step write transaction across any combination of sources. Each step has a forward action and a compensation action. The platform durably tracks saga state — in-flight sagas survive restarts. Gap analysis automatically identifies steps missing compensation handlers.

  • Automatic compensation (rollback) if any step fails
  • Durable state tracking — survives process restarts
  • Gap analysis for missing compensation handlers

Saga Templates

Save parameterised saga definitions by name with typed parameters (string, number, boolean). Use {{paramName}} for structural JSON substitution and @paramName in SQL for query parameters. Execute saved templates by name, supplying only the runtime values.

  • Named, reusable saga blueprints with typed parameters
  • JSON structural and SQL query parameter substitution
  • Execute by name — no need to resend the full saga definition

Virtual Tables

Define a named SQL view that spans multiple sources. Reference it in any subsequent query as if it were a real table. Virtual tables are managed through the control plane UI or API and act as reusable, named query abstractions across your federated data estate.

  • Cross-source named SQL views
  • Reference as real tables in any query
  • Managed via control plane UI or API

Full Observability

Execution Timeline

Waterfall view per request: per-source fetch duration, federation phase, and total time.

Per-Source Breakdown

Rows fetched, estimated bytes, predicate/projection pushdown status, executed SQL per source.

Saga Step Drill-Down

Per-step duration, success/failure, and compensation status for every saga execution.

Full Audit Log

Every query and saga execution logged with full telemetry. Searchable execution history.

Connectivity

Connect once. Query everything.

Relational Databases
SQLite SQL Server PostgreSQL MySQL MariaDB Oracle Firebird IBM DB2 SAP HANA Informix MS Access
NoSQL
MongoDB Couchbase Cassandra Redis
APIs & Services
REST APIs SOAP Services

Basic Auth, custom headers, template-driven — no WSDL proxy required.

On-Premises & Legacy Phase 3
FoxPro CSV ODBC

Via Kiwi Agent — a lightweight on-prem proxy over mTLS/gRPC. No inbound firewall rules required.

Three Query Surfaces. One Execution Engine.

Connect from any tool, language, or platform — all backed by the same federation engine.

REST API
HTTP/JSON Port 8080

SDK clients, web applications, and CI pipelines. A .NET client library (CrossDbQuery.Client) wraps all endpoints with strongly-typed methods for queries, sagas, templates, virtual tables, and telemetry.

PostgreSQL Wire Protocol
TCP Port 5432

Connect Tableau, Power BI, pgAdmin, psql, or any PostgreSQL-compatible tool directly to Kiwi Fabric — no driver changes, no configuration, just point at the host and port.

Arrow Flight SQL
gRPC/HTTP2 Port 8815

High-throughput analytics clients — Apache Spark, Polars, DuckDB, and any Arrow Flight-compatible framework. Columnar transport for maximum query throughput.

Control Plane UI — Kiwi Web

A browser-based control plane ships with Kiwi Fabric for managing sources, writing queries, and monitoring executions.

Playground

Write and run ad-hoc cross-source SQL queries with live source breakdown and execution telemetry.

Saga Runner

Compose and execute distributed saga transactions interactively — step by step with real-time status.

Saga Templates

Manage saved parameterised saga blueprints and test them with inline execution.

Query & Saga Log

Full execution history with timeline waterfall and per-source detail for every query and saga.

Data Sources

Register and manage connections to all your databases, APIs, and services in one place.

Capabilities

Declare what each table supports — read predicates, write modes, and compensation handlers.

Virtual Tables

Define, test, and manage named cross-source SQL views as reusable query abstractions.

Users & API Keys

User management with scoped API key issuance for secure programmatic access.

See It In Action

Three interactive flows — federated read, distributed saga write, and automatic compensation on failure. Press any tab to replay.

Caller

ANY APP · ANY LANGUAGE

KiwiFabric Core

REST API · PG WIRE · ARROW FLIGHT SQL

KiwiFabric
Cross-Source Federation & Saga Orchestration
Schema Registry
sources, tables & columns
Push-down Optimizer
filters → native queries
Saga Orchestrator
multi-step coordination
Result Combiner
stitches fragments → 1 set
FRAGMENT / STEP QUEUE
idle

Data Sources

REGISTERED & QUERYABLE

RELATIONAL
SQL ServerSQL
PostgreSQLSQL
MySQL / OracleSQL
NOSQL
MongoDBdoc
Cassandra / Couchbasecol
Rediskv
SERVICES
REST APIhttp
SOAP servicexml
Ready — press play to run the federated read flow.
Read / commit / success SAGA write step (CUD) Failure & compensation (rollback)
Technical Summary

How Kiwi Fabric Executes a Federated Query

Every query — regardless of which interface it arrives from — passes through the same five-stage execution pipeline. The platform is stateless in the query path; it never stores a copy of your data.

Deployment Model

Silo (single-tenant) deployment — one instance per customer. Customer database credentials never leave the customer's own instance.

AWS Marketplace Azure Marketplace GCP Marketplace Kubernetes Docker
1
Query Arrives

A SQL query arrives via REST API, PostgreSQL wire protocol, or Arrow Flight SQL — all handled by the same engine.

2
SQL Parsing & Source Mapping

The SQL is parsed; each referenced table is mapped to its registered data source and the appropriate handler.

3
Parallel Dispatch

Handlers are dispatched in parallel — each fetches only the rows and columns it needs via predicate and projection pushdown where the source supports it.

4
In-Memory Federation

The federation engine joins, aggregates, and sorts the combined result set from all sources in memory.

5
Result Returned

The unified result is returned to the caller. Telemetry is written asynchronously — zero impact on query latency.

Who Kiwi Fabric Is For

Built for teams that manage heterogeneous data at scale.

Engineering Teams with Multiple Databases

Need cross-source reporting without building and maintaining ETL pipelines. Kiwi Fabric delivers live, unified query results across every database you own — without a warehouse in the middle.

Platform Teams Building Internal Data APIs

Spanning legacy and modern systems to expose a unified data layer to internal consumers. Kiwi Fabric's virtual tables and REST API surface make it straightforward to build stable, versioned internal data APIs.

ISVs Embedding Cross-Database Query

Embedding cross-database query capability into their product without building a federation engine. The CrossDbQuery.Client .NET library and REST API give ISVs a clean integration surface.

Enterprises with Distributed Write Requirements

Needing saga-pattern durability across multiple databases without building it themselves. Kiwi Fabric's distributed saga engine with automatic compensation handles the hard parts — durable state, restart recovery, and gap analysis.

Private Preview

Interested in Kiwi Fabric?

If cross-source federation or distributed write orchestration is on your roadmap, we'd like to hear your requirements. Early design partner conversations directly shape the capabilities we prioritise for launch.

Get Notified at Launch Share Your Use Case