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.

Launched Data & Config Commercial
Get Started Explore a Use Case
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. Native client libraries for Python, .NET, Java, and Node.JS wrap all API endpoints with strongly-typed, idiomatic 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.

Native Client Libraries

First-party client libraries for Python, .NET, Java, and Node.JS. Each provides strongly-typed, idiomatic access to the complete Kiwi Fabric API surface.

Python pip install
·NET
.NET NuGet
Java Maven / Gradle
js
Node.JS npm install

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.

Ask Fabric AI

Ask Your Data.
Let AI Help Build the Query.

Natural-language questions become federated SQL — reviewed, edited, and executed against live data across every registered source. No SQL expertise required to get started; full SQL control when you need it.

01 Ask
Natural Language

Describe what you need in plain English — no SQL required

›
02 Generate
AI Produces SQL

Fabric AI generates the cross-source SQL query automatically

›
03 Review
Inspect & Edit

Developer reviews, edits, or runs the generated SQL as-is

›
04 Execute
Live Federated Run

Query runs across all relevant sources against live data

›
05 Results
Unified Result Set

Federated rows returned with full per-source execution telemetry

Ask Fabric AI

Type a question in natural language — "show me the top 10 customers by total order value" — and Fabric AI generates the cross-source SQL. The query can span tables from different databases in a single statement.

  • Natural language input, SQL output
  • Schema-aware — AI understands your registered sources
  • Available in the Query Playground (Kiwi Web)
Generated SQL, Fully Editable

AI output is not a black box. The generated SQL is presented in a full editor — review it, modify it, or run it as-is. Developer control is always one step away, regardless of how the query was created.

  • Full SQL editor — not just a prompt interface
  • Cross-source joins, aggregations, and filters
  • Modify the generated query before executing
Live Results & Execution Telemetry

Results are fetched live from each source at query time. The Execution Plan tab breaks down per-source fetch duration, rows returned, pushdown status, and total execution time — for every query, AI-generated or manual.

  • Results and Execution Plan tabs side by side
  • Per-source row count and timing breakdown
  • Same telemetry for AI-generated and manual queries

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.

Enterprise Security

Security Down to the Row and Column.

Authentication, role-based authorization, row-level filtering, and column-level access control — enforced uniformly at the data surface before any result is returned, without reimplementing controls in each underlying system.

01
Authentication — Verify Who Is Connecting

Kiwi Fabric supports multiple authentication mechanisms to accommodate different client types and enterprise identity requirements.

Password Authentication API Key Authentication Domain-Based Authentication
02
Role-Based Authorization (RBAC) — Control What They Can Do

Authenticated users are assigned one or more roles. Roles define the scope of permitted operations — which sources, tables, and capabilities a user may access. Permissions are granted through roles, not directly to users.

Role Definitions Permission Grants Source & Table Scoping
03
Row-Level Security — Restrict Which Rows Are Returned

Row-level security predicates are injected at the data surface layer before queries are dispatched to source systems — ensuring that unauthorized rows are never returned regardless of the query submitted.

Role-Based Row Filters Applied Before Source Query Consistent Across All Sources
04
Column-Level Security — Restrict Which Columns Are Accessible

Columns outside a role's permitted set are omitted from query results at the data surface — without requiring each underlying source to implement independent column masking or filtering.

Role-Based Column Access Applied at Data Surface Layer No Per-Source Reimplementation

Security is applied once at the Kiwi Fabric data surface and propagated consistently across every registered source — eliminating the need to replicate access controls across individual database systems.

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 Kiwi Fabric .NET client 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.

Adopt with Kiwify Labs

From Evaluation to Production — Together

Every organization has a different data landscape. Kiwify Labs works with your architecture and engineering teams to identify appropriate federation opportunities, validate Kiwi Fabric against real use cases, design the integration approach, and help take the solution into production.

We understand that adopting a data federation layer touches existing systems, data governance policies, and team workflows. Our engineering expertise reduces the risk and shortens the path from evaluation to confident production use.

Identify use case → Validate with real data → Design integration → Implement → Production adoption
What we work on with you
  • Identify federation opportunities across your existing data sources
  • Run a focused POC against your real data and real queries
  • Design the virtual schema and capability registrations for your environment
  • Integrate Kiwi Fabric into your application and data architecture
  • Tune performance, optimize predicate pushdown, and validate SAGA flows
  • Enable your team to own and extend the solution post go-live
Explore Kiwi Fabric with Your Use Case Talk to an Architect
Launched

Ready to Explore Kiwi Fabric?

Kiwi Fabric is now available. If cross-source federation or distributed write orchestration fits your architecture, talk to our team to explore how Kiwi Fabric can work in your environment.

Get Started Explore a Use Case