Sisense is an embedded analytics solution that aims to help you deliver your dashboards faster than a custom, in-house build. This article will help you navigate its approach and determine if it’s a good option for your project.
Sisense started as an internal reporting tool and later introduced its embedded offering. Today, we're reviewing Sisense embedded analytics from a developer's perspective. You'll learn:
- The key features
- Different methods for embedding dashboards
- Sisense embedded performance
- Which security features Sisense offers
- Sisense pricing details
And much more.
What is Sisense and how does it work?
Sisense is a business intelligence (BI) and analytics platform that helps companies analyze, visualize, and embed data from multiple sources into dashboards and reports.
Founded in 2004 in Israel, Sisense started as a traditional BI tool centered around its ElastiCube in-memory data engine. Over time, Sisense expanded its capabilities. In 2019, it acquired Periscope Data to blend code-first analytics with no-code BI and began focusing heavily on embedded analytics for product teams.
In practice, Sisense allows you to combine data from various databases, cloud warehouses, and files, transform and model that data, and create interactive visual dashboards. These dashboards can then be shared internally or embedded into external applications for end users.
It supports flexible deployment: you can run it fully on-premises (self-hosted on your servers), use Sisense’s cloud service, or a hybrid approach. This makes it adaptable to different security and infrastructure needs.
Despite its embedded analytics push, Sisense’s core architecture still reflects its BI roots. The platform was originally built for internal analysts and dashboards, so it wasn’t initially optimized for seamless embedding into modern web apps.
Sisense embedding methods
Like many other business intelligence tools on the market, Sisense provides various embedding options, depending on your available resources and knowledge. If you're interested in white labeling Sisense, there are a few things you should know.
Embedded via iframe
The simplest approach is to embed a Sisense dashboard as an <iframe> in your web app. This essentially loads the entire Sisense web application UI inside a window on your page. It’s quick to set up and requires minimal coding – you just generate an embed link and put it in an iframe.
Note: If you need to show different data to different users, then you’ll need to also set up JSON Web Tokens (JWT) so that when the user visits your app, you authenticate them, generate a signed JWT (with typ, alg, iat, sub, jti, etc.), and redirect the iframe to Sisense with that token.
However, iframes bring disadvantages: they load a lot of overhead (the whole Sisense app loads in yours), which can make the dashboards load painfully slowly. Customizing the look or feel of the app is very limited. Aside from some URL parameters for basic tweaks, you’re practically stuck with what Sisense shows.
Also, iframes create a separate context, so the embedded content may not feel native to your app. For example, an iframe isn’t responsive, can’t easily inherit your app’s CSS styles or allow seamless interactions across the iframe boundary.
Embed SDK (JavaScript)
Sisense offers an Embed SDK that wraps an iframe but gives a bit more control via JavaScript.
This is essentially a JS library that lets your application initialize and interact with the embedded Sisense iframe. With the Embed SDK, developers can listen for events (e.g., when a user clicks a chart) or programmatically apply filters or theme changes.
This improves integration slightly. For instance, you could synchronize a date filter in Sisense with a date picker in your app. However, under the hood, it’s still an iframe showing a Sisense dashboard, so many limitations remain. Ultimately, the overall UI is still Sisense’s, and deep customization isn’t possible.
You also need to include and manage the SDK in your app, and you’re limited to the APIs Sisense provides.
Sisense JS (JavaScript API without iframe)
For more advanced use cases, Sisense has a JavaScript library often called SisenseJS or the JavaScript Embed API.
This approach does not use iframes; instead, it allows you to load Sisense dashboards or individual widgets directly into your app’s DOM. SisenseJS can fetch and render the data and charts from Sisense in a container on your page. This gives you finer control over layout and styling compared to an iframe, whilst giving you a more responsive experience.
You can embed specific visualizations, mix them into your pages, and control interactions more freely.
The trade-off is increased complexity: you’ll need to write more code to handle how and where each widget renders, manage authentication to Sisense’s APIs, and ensure the Sisense runtime loads in your app.
It’s more customizable but requires more work, and you are still tethered to Sisense’s predefined widget types and data models.
Compose SDK (headless embedding)
Launched in 2023, the Compose SDK is Sisense’s latest method, aimed at a headless embedding approach. It’s a set of front-end libraries for React, Angular, and Vue, with TypeScript support.
Instead of embedding an existing Sisense dashboard, you use Compose SDK to run data queries (through Sisense’s analytic engine) and then render the results using your code – for example, feeding the data into a custom chart component in React.
This gives more flexibility in UI/UX: You’re not showing any of Sisense’s interface, just the data and perhaps some Sisense-provided chart components. Compose SDK is composable and modular, and you can use Sisense’s query engine and mix it with your visual components to create customizable widgets.
While this eliminates the need for iframes and improves front-end flexibility, Compose SDK still requires a full Sisense backend to run behind the scenes.”
The summary
Each method has pros and cons. The classic iframe approach, while easy, is often not ideal for modern SaaS apps. Performance is a key concern: an iframe embed loads almost the entire BI app within your product, so it’s inherently heavier and slower than a native UI.
Customizability is minimal. You can’t easily change how a Sisense dashboard looks beyond superficial theming or hiding some toolbar elements. Scalability can suffer too. If you embed multiple dashboards or need many users accessing them at once, you’re essentially replicating many full BI app instances, which can strain resources.
Responsiveness is also a concern with the iframe approach. When users change screen size, or view on mobile, it can leave the UX in a horrible mess.
The newer headless approach via Compose SDK improves on many of these points. Because Compose lets developers use Sisense purely as a backend (query engine) and design the front-end freely, it avoids the “iframe in a box” limitation.
Developers can make the analytics feel truly part of the application, matching the app’s look and enabling two-way interactions (your app can react to analytics events and vice versa). Compose SDK also loads only what’s needed (e.g., fetch data for one chart, not load the whole Sisense UI), so it can be more performant.
However, Compose SDK still has caveats.
You still need a full Sisense deployment running behind the scenes. That means maintaining the Sisense infrastructure (either paying for their cloud or managing your own servers with Sisense) and dealing with Sisense’s data model (Elasticube or live data connections).
In essence, Compose SDK is a new “skin” over an old engine. It gives you flexibility on the front-end, but the backend is the same Sisense platform with its complexity and potential bloat.
Teams evaluating Compose often find that while it’s a welcome improvement, it can be complex to set up initially and doesn’t completely resolve performance issues if the Sisense back-end isn’t tuned for high loads. It’s also relatively new, so community support and examples are limited compared to more established frameworks.
Data visualization options
Sisense offers a decent range of standard chart types: bar charts, line graphs, pie and donut charts, KPIs, tables and pivot tables, scatter plots, gauges, maps, etc.
For many common dashboard needs (e.g., showing a sales trend over time or a breakdown of categories), Sisense’s built-in visuals are sufficient. It also provides some customization on these visuals, such as choosing colors, chart orientation, basic formatting, and interactive filtering and drill-down.
However, compared to leading visualization-centric BI tools (like Tableau or Microsoft Power BI) or specialized libraries, Sisense’s charting library can feel limited.
Users have pointed out that certain complex visuals or niche chart types aren’t available out of the box. For example, you might struggle to create advanced map visualizations or a custom histogram with auto-bucketing in Sisense, whereas those might be straightforward in Tableau.
Note: You might want to look at the full Sisense vs Tableau comparison, too.
Sisense tends to cover the basics well, but you could hit a wall if your product’s analytics require highly tailored or innovative visualizations.
The Sisense philosophy historically has been “use what’s in the box.” If the default chart options don’t meet your needs, Sisense does offer an avenue for extension called Sisense BloX.
BloX is a framework for building custom widgets using HTML/CSS/JS within Sisense dashboards - effectively JSON objects rendered as HTML inside widgets on your dashboard.. Theoretically, you can create almost any visualization or custom UI element with BloX. In practice, developers report that BloX has a steep learning curve.
It’s powerful (you can code interactions and dynamic visuals, similar to writing mini web apps inside Sisense), but documentation is sparse, and the process can be cumbersome. It’s akin to writing code in a constrained environment, meaning extra overhead to integrate with Sisense’s data and ensure it works in the dashboard context.
For many teams, this complexity defeats the purpose of a quick BI tool – if you have to code extensively to get the visual you want, it might be easier to use a more flexible framework from the start.
This points to an architectural constraint: Most embedded analytics platforms decide for you what charts you can use and how they behave. Sisense allows theme changes and some scripting, but ultimately, you are working within its predefined visualization framework.
If a specific chart type or a highly bespoke look is required, you might be stuck unless you invest significant developer time.
This is where headless embedded analytics shines: a headless tool (such as Embeddable) lets developers bring their own chart libraries or custom visuals because the front end is entirely under their control. Instead of waiting for the vendor to support a chart or hacking around limitations, you can import any JavaScript charting library or write your own visualization component.
Self-service capabilities
Sisense has its roots in empowering non-technical users, so it does have notable self-service features, primarily oriented towards internal use by business stakeholders or data-savvy team members.
For internal users, Sisense provides a drag-and-drop dashboard builder interface. A data or product team can prepare datasets and build a model in Sisense, and then business users (with the right permissions) can use those to create their own charts and dashboards through a visual interface.
However, ease-of-use is a mixed bag. Some users find Sisense intuitive, while others mention a learning curve. Because Sisense offers many options and settings, new users can feel overwhelmed. One user commented that it had “what feels like an unlimited number of dashboards – it’s easy to drown yourself in data.”
In other words, without good training or governance, a self-service Sisense environment might sprawl into dozens of dashboards and widgets, which can confuse end users.
From a developer’s perspective, you might ask: how do these self-service features translate to an embedded analytics scenario?
If you embed Sisense in a SaaS app for your customers, will those customers be able to self-serve, or is it only for internal analysts? Traditionally, Sisense’s self-service was aimed at internal use or partners with access to the Sisense UI. In an embedded context, allowing end-users to create or modify dashboards is possible but not straightforward out-of-the-box.
You would essentially be embedding parts of Sisense’s UI that allow editing or using Sisense’s APIs for creating dashboards on the fly. Sisense does have a concept of different user roles (like viewers, designers, admins) and theoretically, you could expose a “design mode” to certain power users in the embedded interface.
But in practice, many companies choose not to expose the full complexity of a BI tool to end customers, as it could be confusing or require training.
Integrations and data sources
Out of the box, Sisense provides connectors to numerous databases and services. These include traditional SQL databases (MySQL, PostgreSQL, SQL Server, Oracle), cloud data warehouses (like Snowflake, Amazon Redshift, Google BigQuery), NoSQL, and big data sources (MongoDB, Elasticsearch, Hadoop/Hive).
It also connects to SaaS applications (Salesforce, Google Analytics, etc., often via plugins or API connectors).
When using Sisense, you typically have two modes for data:
- In-chip (ElastiCube) mode: Sisense can import data from your sources into its proprietary ElastiCube in-memory data store. You would set up an ETL/ELT process to load data into the cube, and Sisense then performs queries super-fast in memory.
- Live connection mode: Alternatively, Sisense can query some sources live, without storing the data in ElastiCube. For example, Sisense can connect live to Snowflake or Oracle and push down queries to those databases when a dashboard is opened. Live mode ensures users always see up-to-the-minute data from the source and avoids storing data twice.
Beyond data source integration, embedding integration is another consideration. Sisense supports single sign-on (SSO) integration, so you can authenticate users from your application into Sisense seamlessly. For embedded use, Sisense often uses Web Access Tokens (WAT) – basically JWT-like tokens that you generate on your backend and attach to the embed URL, which tells Sisense who the user is and what they can access.
On the API front, Sisense offers a robust REST API and developer tools. You can automate tasks like creating users, scheduling data refreshes, or building new dashboards via API. This means if you want to integrate Sisense deeply (e.g., programmatically create a new dashboard for each new client that signs up to your SaaS, or inject data via API calls), you can. There’s also a Sisense marketplace for plugins.
Modern embedded analytics tools may take a different approach: Embeddable, for instance, doesn’t require you to upload data into a proprietary store; instead, it connects directly to your existing databases or data warehouses using a query engine (like Cube.js) for caching.
That approach can simplify integration because you’re not duplicating data storage, and you can leverage your existing data infrastructure. Sisense, on the other hand, gives you the option to import data for speed, which might be beneficial or might add maintenance overhead depending on your scenario.
Security and compliance
When embedding analytics, security and compliance are paramount. You often deal with sensitive business data and potentially show different slices of data to different users. Plus, if you’re in regulated industries (healthcare, finance, etc.), the analytics platform must meet certain standards.
User security & authentication
Sisense supports robust authentication and authorization mechanisms. For internal use, it has role-based access control (RBAC). You can assign users roles like Viewer, Designer, Admin, and control what data and features they can access.
As mentioned, in embedded use, Sisense uses token-based auth (Web Access Tokens) to securely identify external users and their permissions without requiring separate logins. You can integrate Sisense with SSO providers (SAML, OAuth, etc.) so that Sisense can automatically trust your application’s login.
This provides a seamless user experience: your end-user doesn’t need to log into Sisense separately, but behind the scenes Sisense knows who they are.
Row-level security (RLS)
A common requirement in SaaS analytics is that users should only see data belonging to them or their organization (especially for multi-tenant apps). Sisense implements RLS through data security policies and user/group filters.
An admin can define rules like “Users in group X can only see records where region = X” or similar. These can be set at the data model level (in the ElastiCube or live data settings) and Sisense will enforce them on queries.
You can also tag users with attributes and reference those in security formulas. This is quite powerful, but it can get complex at scale. If you have tens of thousands of users each needing isolated data, managing all those groups and filters in Sisense could become a heavy admin task. There’s also the challenge of ensuring those rules are updated as data models change or new tenants are onboard.
One limitation is that Sisense’s RLS is tightly coupled with its own user management and data models – it’s not something easily driven from your application code. Every time a user should see filtered data, Sisense needs to know about that user or at least the filter context. This can mean syncing user lists or maintaining mapping tables in Sisense.
Multitenancy
Sisense can be deployed in ways to handle multitenancy (e.g., separate ElastiCubes per tenant vs one cube with RLS for all tenants). Both approaches are used. Separate cubes per tenant give strong isolation but are resource-intensive (each tenant’s data is siloed physically).
One cube with RLS is more efficient, but it puts a lot of responsibility on correctly setting up the RLS rules to avoid leaks. Many Sisense OEM (embedded) customers historically used separate cubes or instances for big clients to ensure performance and security isolation, but that increases infrastructure costs.
Compliance
Sisense is ISO 27701 certified and supports GDPR-related features such as data deletion. SOC 2 compliance is expected for enterprise deployments, but should be confirmed during procurement.
The better way to manage security in an embedded context
Now, consider Embeddable’s approach to security as a contrast. Embeddable uses a backend-first, code-driven RLS. Instead of configuring security rules in a UI, you typically enforce them in code or configuration using your own logic.
For example, when your app issues a query through Embeddable, you can dynamically set a ‘security context’ (effectively filters) based on the user’s ID or tenant (or any other key value pairs you may want to use). You simply provide a security context (like tenant_id = 123) when making a server-side request for your JWT security token, and this gets applied as a filter to every query - to restrict results to that tenant.
This approach is very flexible and scales well because it’s just part of your application logic, version-controlled and testable like any other code, rather than lots of UI rules. It also means if you already manage user roles and permissions in your app, Embeddable can trust those and enforce accordingly, without needing a parallel user database.
In terms of compliance, a headless tool like Embeddable typically sits in your tech stack, so compliance is more about how you deploy it. For instance, Embeddable can be offered as a cloud service but connecting to your database – if your database is on a specific cloud or region, you can deploy the semantic modeling and caching layer there too.
Scalability in features
Sisense was built with big data in mind to a degree. Its in-chip engine can handle quite large datasets if you give it enough memory and computing power. It also introduced the Analytical Engine and improved caching in recent versions to boost query performance.
Sisense can be scaled by adding more nodes to a cluster for load balancing and high availability (in the Linux deployment, it’s Kubernetes-based scaling).
So if you have, say, 1000 concurrent users running dashboards, you could allocate multiple Sisense server pods behind a load balancer to serve the load. Sisense also supports query result caching, which means repeated queries (common in dashboard scenarios) can be served faster from memory.
However, there are known performance bottlenecks as data size grows or queries become complex. As noted earlier, some users see slowdowns when running very large or un-aggregated queries through Sisense. The platform performs best when you’ve done data modeling efficiently (e.g., pre-aggregated large fact tables, applied appropriate indexes or partitions in the source, etc.).
In an embedded scenario, you often can design around this by preparing the data specifically for the dashboards you expose (since you have control over the use case). But if you aim to provide exploratory capabilities on huge data volumes, you might find Sisense needing quite a bit of tuning or hardware to keep things snappy.
One particular feature that scales technically but has pricing impact is concurrency. Sisense’s licensing for OEM (embedded) typically doesn’t limit by named user, which implies you might have many end-users. Instead, they sometimes limit by resources (CPU cores, etc.).
If suddenly thousands of users run heavy queries, you may hit those usage limits or simply overwhelm the infrastructure. Ensuring scalability might mean pushing some computations upstream (aggregating data in the DB or using incremental refreshes).
Feature scalability also refers to whether the platform’s feature set remains effective as you scale. For example, Sisense’s row-level security is fine for tens or hundreds of rules, but would it be manageable for thousands of tenants?
Many Sisense OEMs circumvent that by programmatically managing those rules or isolating data. Meanwhile, a tool like GoodData is explicitly built to manage many workspaces/tenants under one umbrella, which might scale that aspect more neatly.
The cost
Sisense’s pricing in 2025 remains notoriously opaque – they don’t publish straightforward pricing tiers on their website. To get an exact quote, you have to engage with their sales team, who will tailor a price based on your deployment size, use case, and negotiation leverage.
We won't go into extensive details about Sisense pricing as we've covered it in a separate blog post. What you should know is that it's secretive and that it starts at roughly $10,000 per year.
The best alternatives to Sisense for embedded analytics
Sisense is a respected embedded analytics platform, but not always the perfect fit for every use case. The embedding options are less than ideal, and coupled with performance issues and high costs, you have plenty of reasons to shop around for an alternative.
PS. you can get a full overview of Sisense competitors in another blog post.
Embeddable
Embeddable pioneered a developer-first, headless approach to embedded analytics, giving teams full control over the UI/UX and performance of customer-facing dashboards. Unlike Sisense’s all-in-one BI framework, Embeddable’s architecture lets you define every chart and interaction in code. Dashboards load in milliseconds and feel like a native part of your application.
- Unlimited customization: Embeddable’s headless design lets developers embed any visualization. You can extend the library or use custom components, so you're not limited to preset widget types (unlike Sisense).
- Seamless native embedding: Embeddable uses Web Components or a direct React or Vue embed instead of iframes. Analytics render as native parts of your app’s DOM, enabling two-way interactions with no iframe overhead or responsiveness issues.
- High performance: A multi-layer cache and direct queries to your databases ensure sub-second load times even on large data. Embeddable stays snappy where Sisense might slow down.
- Secure & scalable: Designed for multi-tenant SaaS with row-level security by default. Embeddable’s flat-rate pricing (no per-user fees) means you can scale without the cost spikes of Sisense’s licensing.
Teams choose Embeddable over Sisense when they need extreme speed, fine-grained UI control, and an analytics experience that feels truly integrated into their product.
ThoughtSpot
ThoughtSpot offers a search-driven analytics experience powered by AI – a very different approach from Sisense’s traditional dashboard-centric model. Users can type questions in natural language (e.g. "What were our top sales last month?") and get answers back as charts or metrics. This on-the-fly querying, combined with AI features that highlight trends, allows even non-analysts to explore data on their own.
- Embedded analytics via SDK: ThoughtSpot provides a toolkit (“ThoughtSpot Everywhere”) to embed its search bar or interactive dashboards directly in your app. This lets users run ad-hoc analyses within your product’s interface.
- AI-driven insights: ThoughtSpot’s SpotIQ AI automatically finds patterns and anomalies in data. It often surfaces valuable insights that users might not think to ask about, going beyond what Sisense’s manual dashboards provide.
- Big data performance: Built to query cloud data warehouses directly (or use its in-memory engine), ThoughtSpot handles massive datasets in real time – cases where Sisense might need heavy pre-aggregation or struggle with latency.
ThoughtSpot is a compelling alternative for teams that want Google-like, AI-driven analytics on large datasets. It introduces a new search-driven UI (with a learning curve) but delivers insights beyond what static Sisense dashboards offer.
Luzmo
Luzmo (formerly Cumul.io) is a lightweight embedded analytics tool made for SaaS teams who need to add dashboards fast.
Unlike Sisense’s heavy all-in-one BI suite, Luzmo is easy to implement – you can drop in interactive charts with minimal coding. It prioritizes simplicity and a smooth user experience, making it a popular choice when Sisense feels too complex to deploy, but the simplicity comes from having less configuration and customisation options so keep this in mind if you need something to feel native or have custom features.
- Easy dashboard builder: Luzmo provides an intuitive drag-and-drop interface for creating dashboards. Non-technical users can design charts and reports visually, which speeds up development compared to coding everything or navigating Sisense’s more complex interface.
- End-user self-service: Teams can embed Luzmo’s dashboard editor in their app, so end-users can customize or even build their own dashboards (within limits you set). This level of self-service is usually only found in larger BI tools, giving Luzmo a unique edge.
- Fast deployment: You can embed Luzmo’s dashboards via a simple iframe or JS snippet, going live with analytics in days instead of months.
Teams often choose Luzmo over Sisense when they need to deliver basic dashboards fast and with minimal fuss. It covers the essentials with a gentler learning curve and lower cost, which may be ideal for cases where Sisense’s full power isn’t needed.
Wrapping up
Sisense offers several ways to embed analytics, from basic iframes to the more advanced Compose SDK. While it has evolved to meet modern embedding needs, it is still a traditional BI tool under the hood.
That brings trade-offs in performance, flexibility, and developer effort. Customization is possible, but often at the cost of complexity and load time. For teams building customer-facing apps, those limitations can slow down development and user experience.
Embeddable takes a different approach. We offer a headless, developer-first architecture that removes the common bottlenecks of traditional BI tools. You get full control over the front end, native integration with your app, fast dashboard rendering, and security built into your codebase. If you're looking for embedded analytics that feels like a part of your product, Embeddable is the smarter choice.
Get access to Embeddable today.
Frequently asked questions
Is Sisense good for embedded analytics?
It works, but it's not the most efficient. You can embed dashboards using iframes or SDKs, but customization and performance are limited unless you use the newer Compose SDK.
Can Sisense handle large datasets?
Yes, but performance depends on your setup. The ElastiCube engine can be fast with optimized models, but live queries or poorly modeled data can cause delays.
Is Sisense expensive?
Yes. Pricing typically starts around $10,000 per year for on-premise use. Cloud deployments or OEM use cases often start closer to $20,000–$25,000 and can go well over $100,000 per year if you need advanced features or performance at scale.
What are better options for developers?
Embeddable offers full control with a headless architecture. ThoughtSpot supports natural language search and real-time insights. Luzmo simplifies deployment and editing.
Can you self-host Sisense?
Yes. Self-hosting gives more control over security and cost, though it requires more maintenance and infrastructure planning.
