QueryPanel vs Sisense

Enterprise embedded analytics and OEM-style programs.

Sisense is a long-standing analytics platform with strong enterprise traction. Teams often evaluate it when they need a full embedded BI stack, semantic modeling, and services-led rollout for complex customer bases.

Start building Read the docs

Comparison at a glance

This table summarizes typical positioning. Every vendor changes over time—validate details against current documentation and your security review.

Dimension	Sisense	QueryPanel
In-app experience for end users	Embedded programs often lean on vendor-hosted surfaces or iframe-style modules, depending on product packaging and deployment.	First-class `@querypanel/react-sdk` components—`QuerypanelEmbedded` for a full dashboard, or `QueryPanelProvider` with `QueryInput` / `QueryResult` for a bespoke flow. They render in your React tree like any other product screen (layout, router, modals, tokens)—not a separate iframe "mini app" on another origin. Mint short-lived JWTs on your server; never ship your workspace private key to the browser.
Primary interface	Dashboards and modeling workflows aimed at analysts and BI teams.	Product teams lead with `@querypanel/react-sdk` for customer UI; `@querypanel/node-sdk` on your backend for signing, schema sync, and `ask()` from API routes.
Trainable knowledge & steering	Correctness is anchored in governed metrics and BI modeling; ad-hoc SQL exemplars and column-level glossaries are usually separate analytics workflows from product code.	Gold SQL queries (curated examples the model prioritizes), database annotations (business context on tables/columns, re-embedded with schema), glossary (domain terms and definitions), and tenant-level definitions (isolation field, enforcement, and per-tenant sync context so every ask() is grounded in the right customer slice—not a one-size global prompt).
AI / natural language	Varies by product line; often centered on governed exploration inside the BI suite.	Natural language to SQL is a first-class path, designed for customer questions inside your app.
Multi-tenant SaaS fit	Achievable with modeling and services; complexity scales with program maturity.	Tenant context and tenant-scoped SQL generation are core to the embedded workflow.
Credentials & data plane	Depends on deployment; commonly involves moving data through the vendor-controlled path you choose.	You execute SQL in your environment; QueryPanel focuses on generation and UX, not holding database credentials.
Time-to-first embed	Often measured in quarters when programs include modeling, rollout, and customer onboarding.	Designed for days-to-weeks when your schema and tenant model are already defined in Postgres or similar.

Trainable knowledge base

Four layers your team—and your tenants—can train for better answers

Natural language is only as good as the context the model sees. QueryPanel's knowledge system lets you steer retrieval and SQL with curated examples, business meaning on the schema, shared glossary terms, and tenant-aware definitions—so customer-facing analytics matches how your product actually defines revenue, usage, and risk.

Gold queries

Save vetted SQL for recurring questions. Gold examples are retrieved with schema context and treated as the strongest pattern signal when they match the end user's intent—so joins, filters, and metrics follow what your team already proved in production.

Database annotations

Attach free-text business meaning to tables and columns. Annotations are merged into embedded schema chunks (“Business Context”) so search and generation see how revenue, activation, or ARR are really defined in your warehouse—not only raw column names.

Glossary

Define terms customers actually say (“active seat”, “net MRR”, “expansion”). Glossary entries are embedded alongside schema so the model resolves ambiguous language the way your finance and product teams mean it.

Tenant-level definitions

Per-tenant isolation settings and tenant-scoped schema sync mean each customer’s ask() carries the right tenant id and rules—so retrieval and generated SQL respect dynamic per-tenant shape, not a single global tenant-agnostic prompt.

Manage gold SQL and glossary from the dashboard knowledge base; annotations attach business context to schema objects; tenant isolation and sync keep per-customer context aligned. See documentation for SDK routes and ingestion APIs.

When Sisense is the better fit

Honest tradeoffs help your team pick faster—and match how buyers actually decide.

You need a broad enterprise BI footprint with established procurement paths.
You are standardizing on a vendor that already serves centralized analytics and embedded programs together.
You have dedicated data engineering and BI resources to own modeling, rollout, and customer-specific tailoring.

When QueryPanel is the better fit

Especially strong for B2B SaaS shipping customer-facing analytics on Postgres and similar databases.

You want a trainable knowledge system—gold queries, DB annotations, glossary, and tenant-aware definitions—so NL→SQL and charts reflect your business, not generic schema-only guesses.
You want customer analytics to feel like the rest of your product: React components in your shell and design system—not an iframe-hosted analytics app with its own chrome and awkward sizing.
You want `@querypanel/react-sdk` for the embedded UI and `@querypanel/node-sdk` on your API for JWT signing, schema sync, and tenant-scoped `ask()`—a small, composable stack.
You need to ship customer-facing analytics quickly without standing up a classic BI program or months of custom chart UI.
You want AI-native generation (question → SQL → chart) as the default workflow, not a bolt-on.

Ship the customer UI with React—not an iframe

Most teams lead with @querypanel/react-sdk: drop QuerypanelEmbedded on a normal product route, or compose QueryPanelProvider with QueryInput / QueryResult. It behaves like any other React subtree—your app shell, router, modals, and design tokens—not a separate cross-origin iframe "mini app" with its own layout chrome.

The browser talks to the QueryPanel API with a JWT you mint on your server (RS256). Never ship your workspace private key to the client.

React — QuerypanelEmbedded (tsx)

import { QuerypanelEmbedded } from "@querypanel/react-sdk";

// Render like any other page — not an iframe. Mint tenantJwt (RS256) on your server
// with @querypanel/node-sdk; pass only the JWT to the client.
export function CustomerAnalytics({ tenantJwt }: { tenantJwt: string }) {
  return (
    <QuerypanelEmbedded
      dashboardId="your-dashboard-id"
      apiBaseUrl="https://api.querypanel.io"
      jwt={tenantJwt}
      allowCustomization
    />
  );
}

Headless Node SDK (optional, for your API)

Use @querypanel/node-sdk on your backend to attach database clients, sync schema, sign JWTs for the React embed, and call ask() from API routes when you want a fully custom pipeline. SQL still runs with your drivers. Full quickstart in documentation.

Node — QueryPanelSdkAPI (typescript)

import { QueryPanelSdkAPI } from "@querypanel/node-sdk";

const qp = new QueryPanelSdkAPI(
  process.env.QUERYPANEL_URL!,
  process.env.PRIVATE_KEY!,
  process.env.QUERYPANEL_WORKSPACE_ID!,
);

// After attachPostgres / syncSchema — tenant comes from your auth layer
const result = await qp.ask("Revenue by country last quarter?", {
  tenantId: org.id,
  database: "analytics",
});

// result.sql, result.params, result.rows, result.chart — you execute SQL with your driver

Still evaluating Sisense and QueryPanel?

Start on the free tier, embed one dashboard, and compare implementation time against your current shortlist.

Start free All comparisons