Stop Paying for the Same
BigQuery Scan Twice

QueryFuser is a transparent query merger proxy that detects when a dashboard fires multiple queries against the same BigQuery tables, merges them into a single scan, and delivers individual results back. Fewer bytes scanned, less slot time consumed. No code changes. No SDK. Just lower bills.

Start Saving How It Works
35–85%
Fewer bytes scanned per dashboard load
Auto
Cache optimization maximizes BigQuery cache hits
0
Lines of application code to change
The Problem

Every Dashboard Refresh Costs You Money

When a dashboard loads, your BI tool fires a separate query for every tile. An 8-tile dashboard hitting the same fact table runs 8 independent queries, each scanning the same columns. BigQuery charges for every byte scanned, every time — and every query consumes slot time, eating into your capacity or increasing your bill.

Without QueryFuser

  • Dashboard with 8 tiles, each showing SUM(amount) by a dimension
  • Star schema: 100 M row fact table with INT64 keys, 3 dim tables
  • Each tile scans 2 fact columns: amount + 1 join key
  • 8 tiles × 2 cols = 16 column-scans

With QueryFuser

  • All 8 queries merged into 1 query
  • Merged query scans 4 distinct fact columns: amount + 3 keys
  • Dim tables are 100–1,000× smaller than the fact table = negligible scan cost
  • 4 column-scans instead of 16 → 4/16 = 25% of cost
75% savings
How It Works

Four Steps, Completely Transparent

1

Connect

Point your BI tool at QueryFuser as if it were PostgreSQL. Standard connection settings.

2

Intercept

Queries arrive in PostgreSQL dialect. QueryFuser translates them to BigQuery syntax automatically.

3

Merge

Queries from the same dashboard load that hit the same tables are fused into a single query sent to BigQuery.

4

Deliver

Results are split apart and each caller receives exactly the rows they asked for.

QueryFuser architecture: 8 dashboard queries merged into 1 BigQuery scan
Beyond Cost Savings

A Universal Gateway to BigQuery

QueryFuser isn’t just a query merger — it’s a PostgreSQL wire-protocol gateway that makes BigQuery accessible from any tool that speaks Postgres. Query merging saves you money. The gateway unlocks everything else.

Any Tool, One Connection

No BigQuery-specific JDBC drivers, OAuth flows, or service account keys on every client. Connect with a standard host:port + user + password — the same way you connect to any Postgres database.

Centralized Access Control

Stop distributing GCP service account keys to every user and tool. Manage access, audit queries, and revoke permissions in one place. Users never need direct GCP IAM access.

Cost Guardrails

BigQuery charges per byte scanned. Direct access means unchecked queries from every tool and user. QueryFuser lets you merge, monitor, and control what hits your warehouse.

Auto SQL Translation

Write standard PostgreSQL — QueryFuser translates to BigQuery SQL automatically. No backtick quoting, no SAFE_DIVIDE, no dialect headaches. Your tools just work.

Cache Optimizer

Functions like NOW() and CURRENT_DATE() make every query unique, killing BigQuery’s 24-hour result cache. QueryFuser replaces them with literals so identical dashboards get free cached results. Learn more →

Developer Friendly

psql works. \dt works. SQLAlchemy, ActiveRecord, Prisma — all have mature Postgres adapters but limited BigQuery support. Your existing code just connects.

Compatible Tools

Works With Your Dashboard

QueryFuser is compatible with any BI tool that can connect to PostgreSQL and run live queries. No plugins or SDKs needed.

Looker

Enterprise BI platform with LookML modeling. Supports PostgreSQL as a database dialect via JDBC.

Looker Studio

Google's free dashboarding tool. Supports PostgreSQL as a data source with live queries.

Metabase

Open-source BI with native PostgreSQL support. Dashboards fire live SQL on every refresh.

Grafana

Observability and analytics dashboards with a native PostgreSQL data source. Live queries on every panel load.

Apache Superset

Open-source analytics with SQLAlchemy. Dashboards execute live queries on each load.

Redash

Query-first BI tool. Every dashboard widget runs a live SQL query against your data warehouse.

Tableau

Industry-leading visual analytics. Connects to PostgreSQL via JDBC for live query mode dashboards.

Sigma Computing

Spreadsheet-style cloud BI with live queries. Connects to PostgreSQL for real-time exploration.

Rundown BI

Modern BI platform with live query execution. Connects to PostgreSQL for real-time dashboards.

…and any other tool that speaks PostgreSQL wire protocol — DBeaver, DataGrip, psql, JDBC/ODBC clients, etc.

Real-World Savings

The Math Behind the Savings

BigQuery is columnar — it scans only the columns a query references. QueryFuser merges a dashboard’s queries so those columns are scanned once instead of once per tile. Savings depend on column overlap, data types, and partitioning. All numbers below use percentages, which stay valid regardless of BigQuery caching or pricing tier.

① Star Schema — INT64 Join Keys

transactions fact table: 100 M rows, columns sales_amount (FLOAT64), product_id (INT64), store_id (INT64), date_key (INT64). Three dim tables (products, stores, dates), each 100–1,000× smaller than the fact table — negligible scan cost. Dashboard has 8 tiles, each showing SUM(sales_amount) grouped by a dimension from one of the dim tables.

We measure in column-units: 1 unit = one INT64/FLOAT64 column (100 M × 8 B = 800 MB). All numeric types are the same size.

Each tile scans from fact table: amount + 1 join key 2 units per tile
Solo: 8 tiles × 2 units 16 units
Merged: amount + product_id + store_id + date_key 4 units
Savings: 1 − 4/16 75%

High savings because amount appears in all 8 tiles but is scanned only once. Each key is shared across ~3 tiles. The merged query needs just 4 fact-table columns regardless of tile count. Dashboards with more tiles or fewer dims save even more.

② Star Schema — STRING Join Keys

Same schema, but the 3 join keys are now STRING (~32 bytes, e.g. UUIDs). A STRING key at 32 B is 4× the size of an INT64 at 8 B, so 1 string-key column = 4 units.

Each tile: amount (1) + string key (4) 5 units per tile
Solo: 8 tiles × 5 units 40 units
Merged: amount (1) + 3 string keys (12) 13 units
Savings: 1 − 13/40 68%

Less than INT keys (68% vs 75%) because with STRING keys, amount is only 20% of each tile’s cost, so deduplicating it has less relative impact. The 3 large string keys also inflate the merged query’s total cost. The absolute GB saved is still larger though.

③ Single Table — String Dimensions, No Joins

One denormalized events table: 100 M rows, no joins. Columns: amount (1 unit), plus 5 string dimension columns at 4 units each (category, product, region, channel, status). 8 tiles, each grouping amount by 1 string dimension.

Each tile: amount (1) + 1 string dim (4) 5 units per tile
Solo: 8 tiles × 5 units 40 units
Merged: amount (1) + 5 string dims (20) 21 units
Savings: 1 − 21/40 48%

Lower savings because all 5 string dimensions live in the 100 M-row table itself (not in tiny dim tables). The merged query’s column union is wide — 21 of 40 units. The shared amount column still saves 7 × 1 unit, but 5 large dimensions add up quickly.

See Full Pricing Details

Ready to Cut Your BigQuery Bill?

Deploy QueryFuser in minutes. Connect any BI tool using a standard PostgreSQL connection. SQL is translated automatically, concurrent queries are merged, and your BigQuery bill drops. No application changes required.

Get Started Free Learn More

Want a live demo or an on-premise deployment?
Contact us at support@queryfuser.com