Panelite is the analytics layer you embed inside your own product: charts, dashboards, and self-serve reports that render in your app, wear your brand, and respect every row of every customer's permissions. You own the experience. We carry the query engine, the caching, and the multi-tenant isolation underneath it.
// 1. Sign a short-lived, tenant-scoped token (server-side)
const token = await panelite.signEmbed({
dashboard: "shipping_overview",
tenant: "acct_acme",
filters: { region: user.region } // row-level, enforced
});
// 2. Drop the component into your app (client-side)
<PaneliteDashboard token={token} theme={ourTokens} />
// Renders inside your layout. Scoped to acct_acme. Themed as yours.Powering the customer-facing reports inside fast-growing software products
Building customer-facing analytics in-house means a query engine, a charting library, a caching layer, multi-tenant security, and a theming system — then owning all of it forever. Panelite is every one of those, delivered as a component your team ships this sprint.
Forty chart types — time series, funnels, cohort grids, geo maps, retention curves — that inherit your fonts, colors, spacing, and dark mode from design tokens. No recognizable third-party iframe. It renders inside your layout, so it reads as a feature you built.
Hand customers a drag-and-drop builder to create, save, and share their own views — no analyst, no support ticket, no waiting on your roadmap.
A columnar engine with smart caching and pre-aggregation keeps every dashboard instant, whether a tenant has a thousand records or a warehouse.
Every result is scoped to a signed embed token, so a customer can only ever load their own rows. Multi-tenant isolation is the default, not a config someone can forget to set.
Point Panelite at Postgres, Snowflake, BigQuery, or ClickHouse and model once. No reverse ETL, no second copy of your data to sync, secure, and reconcile.
Built to sit on the critical path of your product
The same governed layer powers the dashboard tab, the metric on a record page, the report customers email themselves, and the data they pull through your API. Pick the surface — the security and the speed come attached.
Give every customer a full workspace — saved dashboards, filters, drill-downs — that lives behind your login and matches the rest of your product pixel for pixel.
Drop one chart beside an order, a project, or an account so the number shows up where the decision happens, instead of sending customers off to a separate reports screen.
Let customers schedule a dashboard to land in their inbox every Monday as a branded PDF or link — recurring value that arrives without anyone opening the app.
Expose the same governed metrics as a clean, tenant-scoped API, so technical customers pull their numbers into their own warehouse or spreadsheet without raw database access.
Customer-facing analytics sits on your product's critical path, so the integration has to be the boring kind: typed, themeable, secure by construction, and structurally incapable of leaking one tenant's data into another's view.
A signed-token endpoint on your server and a React component in your app are the whole thing. Pass the dashboard, the tenant, and any filters; the chart renders inside your layout with your styles already applied.
Map your design tokens a single time and every current and future chart inherits your type, palette, radii, and dark mode — no per-chart styling, no slow drift away from your design system.
Short-lived, server-signed embed tokens carry the tenant and its row-level filters, so a client request physically cannot reach data outside its scope. Isolation lives at the query layer, never the UI.
Model 'active users' or 'revenue' once in a semantic layer that ships in your repo, so the number means the same thing in every chart, every export, and the API — and changes get reviewed in a pull request like the rest of your code.
“Customer-facing dashboards were a four-quarter project nobody wanted to staff — the charting library, the caching, the multi-tenant security alone scared us off. We embedded Panelite in nine days and it renders inside our app as if we wrote it. It's now the second-most-opened screen in the whole product.”
“Row-level security is the part I can actually sleep on. Every query is scoped to a signed token, so there's no code path where one tenant sees another's numbers. Our security review went from a six-week blocker to a one-call sign-off.”
“Self-serve dashboards quietly cleared our reporting backlog. Customers build the views they want instead of filing tickets, data questions to support dropped about a third, and 'great analytics' started showing up in the notes on deals we won.”
No per-viewer tax for letting customers see their own data. Build the full embed free in development, then pay on the dashboards and tenants you actually serve in production.
Build and test the full embed, free.
For products putting analytics in front of customers.
For high-tenant platforms and regulated industries.
Most teams render their first live dashboard in a day and ship customer-facing analytics within one to two weeks. The integration itself is a React component plus a server endpoint that signs a token — the longer pole is usually modeling your metrics and matching your design system, not the API.
Every dashboard loads behind a short-lived, server-signed embed token that carries the tenant and its row-level filters. The query engine scopes results to that token, so isolation is enforced at the data layer — there is no UI-only filter a determined customer could bypass. Multi-tenant security is the default, not something you wire up per dashboard.
Yes. You map your design tokens — fonts, colors, spacing, radii, dark mode — once, and every chart and dashboard inherits them. Embeds render inside your own layout rather than a recognizable third-party iframe, so customers experience it as a native feature, not a bolt-on.
No. Panelite queries your warehouse where it lives — Postgres, Snowflake, BigQuery, or ClickHouse — with caching and pre-aggregation for speed. There is no reverse ETL and no second copy of your data to keep in sync or secure.
Both. Ship read-only dashboards you design, hand customers a drag-and-drop builder to create and save their own views, or mix the two per plan and per tenant — all inside the same permission and security model.
Panelite is SOC 2 Type II, with encryption in transit and at rest, scoped access on every query, and a full audit log of dashboard and data access. Enterprise plans add SSO, data residency options, and dedicated infrastructure for regulated workloads.
Get API keys and render your first tenant-scoped, fully themed dashboard today — or walk through a live embed with the team before you write a line.