Skip to content
FFabric
Get started

Federated data layer

One governed query layer over every database you run

Send a structured AST, not SQL. Fabric plans it, applies your row-level security and masking, and answers from Postgres, MySQL, Oracle, MongoDB and Elasticsearch as one fabric.

Sign in API docs
  • Free trial
  • RLS and masking built in
  • Scales with worker nodes
  • No SQL injection surface
POST /api/queries/engineapplication/json
// structured AST: no SQL text anywhere
{
  "type": "SELECT", "schema": "sales", "limit": 50,
  "query": {
    "select": ["id", "customer_id", "total"],
    "from": { "resource": "orders", "source": "Fabric_Hub_Postgres" },
    "filter": { "total": { "$gte": 100 } }
  }
}

// customers.email is masked for this role,
// rows outside your tenant never leave the engine

Connects to the stores you already run

  • PostgreSQL
  • MySQL
  • Oracle
  • MongoDB
  • Elasticsearch

What you get

Everything between your apps and your data

One API, one policy model and one audit trail, whichever database holds the rows.

  • AST-only query engine

    Queries are structured trees, never strings. The engine validates, plans and pushes work down to each source, so raw SQL is rejected by design.

  • Governance, RLS and masking

    Row-level security and column masking by role, enforced for every query path, with an audit log of who read what.

  • Replication and CDC

    Stream changes from source databases into downstream stores, with sync pipelines you can pause, resume and inspect.

  • Triggers and webhooks

    React to inserts, updates and deletes. Signed webhooks, retries with back-off and a control plane to replay events.

  • Multi-tenant by default

    Every request carries a tenant. Data, policies, connections and quotas stay isolated, with admins able to act across tenants.

  • Developer API tokens

    Mint scoped tokens for your services and call the same API the console uses. Revoke any time.

  • Two Swagger specs

    A developer spec for data and queries, and a system spec for admin and operations, each with auth flows and examples.

  • Horizontal scale

    Add worker nodes to spread data and query load. Rebalance and drain nodes from the console without downtime.

Architecture

A distributed fabric, not a single box

Requests enter at the app server, the Citus coordinator plans them across worker nodes, and workers reach your application databases.

Distributed fabric architecture An app server sends queries to a Citus coordinator, which distributes work to worker nodes 1 to N, which read the application databases. Entry App server Auth, tenancy, RLS, AST planner Coordinator Citus coordinator Metadata, shard map, distributed plans Worker node 1 Shards + local exec Worker node 2 Shards + local exec Worker node 3 Shards + local exec Worker node N Add as you grow … Application databases PostgreSQL MySQL Oracle MongoDB Elasticsearch

Scroll sideways on small screens to see the full diagram.

How it works

From connection to answer in three steps

  1. 1

    Connect your sources

    Register a database in the console, discover its schema, and publish the tables you want in the catalog.

  2. 2

    Set the rules

    Define tenants, roles, row-level filters and column masks once. They apply to every query, replication job and trigger.

  3. 3

    Query with the API

    Send an AST or call data CRUD with a developer token. Results stream back as JSON or NDJSON.

Call it from anywherecurl
curl -X POST "https://fabric.fabrixly.com/api/queries/engine" \
  -H "Authorization: Bearer dft_..." \
  -H "Content-Type: application/json" \
  -d '{ "type": "SELECT", "schema": "sales", "limit": 20, "query": { "select": ["id"], "from": { "resource": "orders", "source": "Fabric_Hub_Postgres" } } }'

Worker nodes

Grow by adding nodes, not by rewriting

Start on one node. When data or traffic grows, register another worker from the console and the fabric spreads the shards for you.

  • Add, drain and remove workers with health checks and drift detection
  • Rebalance shards online while queries keep running
  • Distribute large tables by key; keep small reference tables on every node
  • Same API and policies whether you run one node or twenty
1 to Nworker nodes behind one coordinator
0 downtimewhen rebalancing or draining a node
1 APIfor queries, CRUD, replication and triggers

Plans

Start with a free trial, talk to us when you scale

Try Fabric free for the trial period, or contact us for a plan, self-hosting and limits that fit.

Start here

Free trial

Try everything on our cloud.

  • All features unlocked for the trial period
  • Sample tenants and connections
  • Developer API tokens and Swagger specs
Start free trial

Custom

Contact us

Volumes and limits agreed with us.

  • Higher quotas and more worker nodes
  • Self-host with your own licence key
  • Onboarding and migration help
  • Support terms that match your needs
Contact us

Put one governed layer over all your data

Sign in to the console, connect a database and run your first AST query in minutes.

Sign in Read the API docs