QueryPanel vs ThoughtSpot Embedded

Search-driven analytics at scale.

ThoughtSpot popularized AI-assisted search over governed models. Embedded scenarios often emphasize consistent answers on top of curated metrics and a strong operations story for analytics teams.

Start buildingRead 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.

DimensionThoughtSpot EmbeddedQueryPanel
In-app experience for end usersEmbedded search experiences often wrap vendor-managed UI; integration and hosting patterns vary by edition.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.
Experience shapeSearch-first exploration on curated business objects and metrics.Customer questions on your routes, rendered by your React tree, routed to tenant-safe SQL against your operational schema.
Trainable knowledge & steeringSearch quality is driven by governed business objects and metric definitions; layering ad-hoc SQL libraries next to product code is less central to the platform story.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).
Integration ownerAnalytics and data platform teams typically lead modeling and rollout.Product engineering owns the embedded surface; data stays in your existing Postgres / warehouse.
Flexibility vs guardrailsStrong guardrails when metrics are modeled carefully upstream.Faster iteration for product teams that accept owning validation, review, and rollout of generated SQL.
Stack fitBest when the ThoughtSpot stack aligns with your enterprise data architecture choices.Postgres, ClickHouse, BigQuery, and MySQL today—fits teams that want to stay close to operational stores.
Buyer motionOften a top-down analytics platform decision with POCs across data leadership.Bottom-up trial: add `@querypanel/react-sdk` to a route, wire `@querypanel/node-sdk` in an API handler, connect a database, ship.
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.

01

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.

02

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.

03

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.

04

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 ThoughtSpot Embedded is the better fit

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

  • Search and drill across a wide enterprise metric layer is the primary experience you are selling.
  • You already invest in governed semantic layers and want AI on top of that foundation.
  • You need a brand-name analytics platform with a long enterprise track record.

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 embedded analytics as native React—`QuerypanelEmbedded` or composable provider pieces—so customers never deal with a boxed iframe app inside your SaaS.
  • You are embedding analytics into a multi-tenant SaaS product, not rolling out another enterprise BI portal.
  • You want developers to own the stack: React components in your app, Node SDK on your API for auth and `ask()`, not a separate BI release train.
  • You want lightweight onboarding: connect the database, describe tenants, ship dashboards on a normal product route.

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 ThoughtSpot Embedded and QueryPanel?

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

Start freeAll comparisons