Working with Databricks and Cube is a great way to ensure your data engineering team can build and maintain a unified semantic layer for your organization. At a higher level, it is a better means to make cloud data accessible and consistent to every data consumer in and outside of your company.

By combining Databricks’ unified analytics and data store with Cube’s data modeling, access control, caching, and APIs, it’s now possible to deliver consistent metrics securely to business intelligence tools, embedded analytics use cases, and AI agents.

## Why a Semantic Layer?

A semantic layer functions as a middleware component between all of your data sources, including cloud-based data lakehouses, such as Databricks, and downstream applications. Its primary role is to abstract complicated physical data models and present them in a more user-friendly manner with improved field labeling, field descriptions, and dynamically calculated metrics. It serves as a contextual bridge between the data sources and the diverse analytical tools businesses employ for data manipulation, slicing, dicing, and analysis.

![](https://ucarecdn.com/5bcadadb-60ee-4698-bc6e-1f1e2ad8aa71/)

## Why Cube and Databricks?

**Unify your data stack**. Databricks established itself as a high-performance Lakehouse for a **modern data stack**, unifying all data types. Combined with Cube, you will have consistently modeled metrics and performant queries for all your downstream data consumers. 

**Modern data stack** follows several foundational principles and architecture designs: 
* Using a Lakehouse like Databricks as a central data platform
* ELT vs. [ETL](https://www.databricks.com/glossary/extract-transform-load)
* Applying software engineering best practices to data management 

The Cube platform embodies software engineering best practices, empowering data engineers to [handle data models through code](https://cube.dev/docs/product/getting-started/databricks/create-data-model). This capability unlocks the potential to harness version control systems for secure data model evolution management, fostering collaborative efforts and streamlined code reviews. Additionally, it facilitates the integration of a semantic layer into the CI/CD pipeline and the creation of distinct development, staging, and production environments.

**Harness the capabilities and scalability offered by Databricks with Cube.** Cube seamlessly integrates with Databricks, enabling direct queries without the need for data extraction. This ensures that your data remains within the Databricks environment. Cube optimizes performance by leveraging the computing power of your Databricks instance, fully maximizing the scalability of your cloud data lakehouse. Additionally, you have the option to create [pre-aggregations](https://cube.dev/docs/product/caching/getting-started-pre-aggregations) within Cube, reducing the need for small, repetitive queries on your Databricks instance and allowing for background aggregate updates instead. Our aggregate-aware pre-aggregations are fundamentally different from common table or view materializing strategies often employed for performance reasons. With Cube pre-aggregations, users do not need to be aware of objects materialized for performance reasons; instead, they simply issue their queries, and Cube automatically chooses the optimal way to answer, from cache, from a pre-aggregate, or the source.

**Use your Databricks Lakehouse data in any application.** Cube supports your current and future use cases with first-class application programming interfaces (APIs). In addition to our SQL API, Cube also speaks REST and GraphQL, which are often preferred by application developers who are working with common front-end frameworks to develop embedded analytic applications. With Cube, you can take your investment in your Databricks ecosystem and build anything you can dream of.

## A step-by-step guide to building semantic layer with Cube and Databricks

In the below section, we’ll cover a quickstart step-by-step tutorial on how to start with Cube and Databricks. Remember: Cube Cloud is free to start (there is a sign-up button, up and to the right^). No credit card or calls with salespeople are required! :) 

Find a detailed getting started with [Cube Cloud and Databricks](https://cube.dev/docs/product/getting-started/databricks) guide in Cube documentation. 

### Create Databricks and Cube accounts
First, create Cube Cloud and Databricks accounts.

If you don’t have a dataset that you would like to use, you can follow [this guide](https://cube.dev/docs/product/getting-started/databricks/load-data) to create a test dataset in your Databricks instance.

### Connect Databricks to Cube

Please follow these steps to create your first deployment in Cube Cloud and connect it to your Databricks instance.

1. After you [sign in to your Cube Cloud account](https://cubecloud.dev/auth), click “Create Deployment”.

2. Give the deployment a name, select the cloud provider and region of your choice, and click “Next”.

3. Next, click Create to create a new project from scratch.

4. Select Databricks from the list of supported data sources and enter your Databricks credentials to connect to it. Get a [free Databricks account](https://www.databricks.com/try-databricks?utm=cube#account)

5. Once Databricks is connected, Cube can generate a basic data model from your data warehouse schema, which helps you get started with data modeling faster. We'll inspect these generated files in the next section and start changing them.

### Create your data model
Cube follows a dataset-oriented data modeling approach, which is inspired by and expands upon dimensional modeling. 

When building a [data mode](https://cube.dev/docs/product/getting-started/databricks/create-data-model) in Cube, you work with two dataset-centric objects: cubes and views. Cubes usually represent business entities such as customers, line items, and orders. In cubes, you define all the calculations within the measures and dimensions of these entities. 

To begin building your data model, click on “Enter Development Mode” in Cube Cloud. This will take you to your personal developer space.

Once you are in developer mode, navigate to the “Data Model” and click on any file located in the left sidebar to open it.

You can follow [this detailed guide](https://cube.dev/docs/product/getting-started/databricks/create-data-model) on how to make changes to your data model and build new measures and dimensions.

When you are ready to test updates to your data model, you can navigate to [Cube’s Playground](https://cube.dev/docs/product/workspace/playground). The Playground is a web-based tool that allows you to query your data without connecting any tools or writing any code.

### Query your data
You can query Cube using a BI or visualization tool through the Cube SQL API. For a better experience, we recommend mapping the BI's data model to Cube's semantic layer. This can be done automatically with Semantic Layer Sync or manually.

**Semantic Layer Sync**
[Semantic Layer Sync](https://cube.dev/docs/product/getting-started/databricks/query-from-bi) will synchronize all public cubes and views with connected BI tools.
1. Create a new sync by navigating to the “Semantic Layer Sync” tab on the “BI Integrations” page and clicking “+ Create Sync”. 
2. Follow the steps in the wizard to create a sync
3. Replace the fields for user, password, and URL with your BI tool credentials, then click on “Save All”. You can now go to the “BI Integrations” page and trigger the synchronization of your newly created semantic layer.
4. After running the sync, navigate to your BI tool instance. You should see the orders_view dataset that was created in the tool. Cube automatically maps all metrics and dimensions in the BI tool to measures and dimensions in the Cube data model.

**Manual setup**
Alternatively, you can connect to Cube and create all the mappings manually. 
1. You can find the credentials to connect to Cube on the “BI Integrations” page under the “SQL API Connection” tab.
2. After connecting, create a new dataset in the BI tool and select "orders_view" as a table.
3. Now you can map the BI tool metrics and columns to Cube's measures and dimensions.

That was a high level preview. You can create both you Databricks and Cube instances for free to try it out in your own environment.

Great work!

### More resources

Recorded workshop [Getting Started with Cube on Databricks](https://cube.dev/events/unlock-data-cube-snowflake)

Detail on [connecting to Databricks](https://cube.dev/docs/product/getting-started/databricks)


Artyom Keydunov

Deep Dives

Getting Started with a Databricks Semantic Layer

Over the last few weeks, we've announced updates to a few [Cube Cloud](https://cube.dev/product/why-cube-cloud) features that we've launched [earlier in June 2023](https://cube.dev/blog/cube-cloud-update-semantic-layer-sync-data-graph-saml). *Semantic Layer Sync* has expanded its suite of supported BIs with [Tableau](https://www.tableau.com) and *Data Graph* now visualizes [views](https://cube.dev/docs/product/data-modeling/reference/view) alongside [cubes](https://cube.dev/docs/product/data-modeling/reference/cube) to help you get a human-friendly overview of the data model within your semantic layer.

Additionally, we've released *Budgets* to help Cube Cloud customers with [annual plans](https://cube.dev/pricing) stay on top of your Cube Cloud usage.

## Tableau support in Semantic Layer Sync

[Semantic Layer Sync](https://cube.dev/blog/introducing-semantic-layer-sync) makes using Cube with BI tools as easy as possible. With the [latest update](https://app.contentful.com/spaces/6v81z8q9p5kl/entries/qEUh67oCvTTSqPAgB1lVv), Cube Cloud automatically populates and updates data sources within Tableau so you can start building workbooks and dashboards right away.

See how that works:

<video width="100%" controls><source src="https://ucarecdn.com/16a984fa-b3a2-411d-872d-184bc476f46a/video.mp4" type="video/mp4"/></video>

[Check the docs](https://cube.dev/docs/semantic-layer-sync) for details and try it today with your Tableau instance. Semantic Layer Sync with Tableau is available in Cube Cloud on [Premium and above tiers](https://cube.dev/pricing).

## Views support in Data Graph

[Data Graph](https://cube.dev/blog/introducing-data-graph) provides a human-friendly, visual way to explore contents of the semantic layer. It represents the data model as an entity relationship diagram and uses the crow’s-foot notation to mark join relationships between cubes. Data Graph is the best way to familiarize for you and your team to take a bird’s-eye view of the data model.

![](https://ucarecdn.com/bfc3e04a-b690-40bc-a6f8-14a9175fb4fd/)

With the [latest update](https://cube.dev/blog/complementing-data-graph-with-views), Data Graph is capable of visualizing not only [cubes](https://cube.dev/docs/schema/reference/cube) and [join](https://cube.dev/docs/schema/fundamentals/joins) between them, but also [views](https://cube.dev/docs/schema/reference/view) that incapsulate cubes and joins and serve as the front, public-facing layer of your data model.

See Data Graph with views in action and [check the docs](https://cube.dev/docs/cloud/workspace/cube-ide#data-graph) for details:

<video width="100%" controls><source src="https://ucarecdn.com/f4b0f37c-4a46-49fb-865f-7da96a093544/datagraphviews.mp4" type="video/mp4"/></video>

A quick reminder: Data Graph is available to Cube Cloud users on all tiers, so please feel free to check it out.

## Budgets

[Budgets](https://cube.dev/docs/product/workspace/budgets) help you stay on top of your Cube Cloud usage.

With Budgets, you can set up monthly or daily budgets for the Cube Cloud usage and get email notifications when certain thresholds of these budgets are exceeded.

For example, if you have an annual contract worth $12,000, you can set up a monthly budget of $1,000 with thresholds of 70%, 100%, and 120%. Later, you'll get email notifications when any of these thresholds are hit. You can also set up a daily budget to protect against Black Friday-like usage spikes.

<video width="100%" controls><source src="https://ucarecdn.com/038cb7bf-babc-4592-9692-9c3a1ee05449/video.mp4" type="video/mp4"/></video>

Budgets are available to Cube Cloud users on Premium, Enterprise, and Enterprise Premier plans.

## What’s next in Cube Cloud

While we're working on the next batch of Cube Cloud features, let me remind you that we're always happy to hear your feedback. Please don't hesitate to [get in touch](https://cube.dev/contact) or reach out in our [Slack community](https://slack.cube.dev) of more than 9,000 data practitioners.

Igor Lukanin

Changelog

Updates to the newest features and tools to control your Cube Cloud usage

Cube Cloud update — Tableau in Semantic Layer Sync, Views in Data Graph, and Budgets

Three months ago, we've introduced [Semantic Layer Sync](https://cube.dev/blog/introducing-semantic-layer-sync) to completely bridge the gap between the semantic layer and BI tools and enable instantaneous, zero-friction self-serve analytics. We've launched with several [supported BI tools](https://cube.dev/docs/product/workspace/semantic-layer-sync#supported-tools) and promised to gradually expand the spectrum of BI tools that work with Semantic Layer Sync.

**Today, we're delivering on that promise and introducing the Tableau support in Semantic Layer Sync.** Now you can author the data model in Cube Cloud and have it seamlessly synchronized with [Tableau Cloud](https://www.tableau.com/products/cloud-bi) or [Tableau Desktop](https://www.tableau.com/products/desktop) where you can access the data from the semantic layer to build workbooks and dashboards.

In the following demo video, you can see that it takes seconds to configure Semantic Layer Sync and surface a [view](https://cube.dev/docs/product/data-modeling/reference/view) from Cube's data model to a workbook both in Tableau Cloud and Tableau Desktop:

<video width="100%" controls><source src="https://ucarecdn.com/16a984fa-b3a2-411d-872d-184bc476f46a/video.mp4" type="video/mp4"/></video>

Over the last months, Semantic Layer Sync has proven itself as a feature that saves a lot of time for data engineers who define metrics in the semantic layer and enable self-serve analytics for their end users in BI tools. Now, it's time to integrate Semantic Layer Sync in your Tableau workflow.

**Semantic Layer Sync with Tableau is available in Cube Cloud on [Premium and above tiers](https://cube.dev/pricing), and [you can try it today](https://cubecloud.dev/auth/signup).** Please check the [documentation](https://cube.dev/docs/product/workspace/semantic-layer-sync#tableau) to learn more about accessing and configuring this feature. Join our Slack community at [slack.cube.dev](https://slack.cube.dev) to share your thoughts and opinions about this update.

If you'd like to see Semantic Layer Sync in action, you can also watch the recordings of recent webinars where we demonstrated and discussed how Semantic layer Sync works with [Preset](https://event.on24.com/wcc/r/4243489/38E64F4551ABDA2967D79B9FFEAE8D3D) and [Metabase](https://event.on24.com/wcc/r/4321808/0C4A58D931932D9BBDD35D7FADB71776), other popular BI tools.


Tableau

Access data from the semantic layer to build workbooks and dashboards

Introducing Semantic Layer Sync with Tableau

For any cloud-based data vendor, your public cloud alliances are among the most complicated, and most important. In Cube’s case, as the universal semantic layer for building data applications, we deploy our product Cube Cloud on public cloud infrastructure and we connect to data sources and power applications built primarily on the public cloud. Recently, we have taken a major step forward with our partner Amazon by making them the first cloud marketplace that you can purchase Cube Cloud on. 

Cube Cloud now has a [public listing on the AWS Marketplace](https://aws.amazon.com/marketplace/pp/prodview-cshbof57nzudw) which we could not be more excited about. Our customers have long had the ability to deploy Cube Cloud on AWS infrastructure, but during my tenure here we have been frequently asked about purchasing via AWS Marketplace. Customers want to do this for lots of reasons, but the most common are the ability to utilize their prior AWS committed spend, wanting a standard AWS EULA, or simply enjoying a more speedy procurement process. 

No matter the reason, we’re happy to be able to provide this option for our customers, should they want it. Flexibility and respecting our customers' right to choose the tools that best suit their needs is a core value of Cube, and we’re happy to extend this idea to the purchasing process as well. Cube customers who choose to purchase Cube Cloud via the AWS Marketplace will have access to all of the same editions of the software in the same configurations as they have when purchasing directly from Cube.

We are excited about taking this step to deepen our relationship with our partners at Amazon and I look forward to continuing to expand our integrations with AWS data and analytics technologies such as Amazon Redshift, Amazon Aurora, Amazon RDS, Amazon Athena and Amazon Quicksight. I would like to thank all of our partner contacts at Amazon who have helped us along the way with this partnership.

If you would like to learn more about how Cube Cloud can help you integrate all of your data sources into a single easy to manage data model and define consistent metrics accessible by all of your data applications then please [reach out](https://cube.dev/contact). We’re happy to help explore how you can build with the combined power of AWS and Cube.


Brian Bickell

News

A community for our customers and partners.

Cube Cloud Now Available on the AWS Marketplace

## Hard work pays off

When you’re at a growing company like Cube, everything is moving so fast that you don’t often take stock, slow down, and appreciate how far you’ve come. But this week has been a moment to do just that as we were honored to be recognized as a [Leader in GigaOm’s Sonar for Semantic Layers and Metrics Stores](https://cube.dev/gigaom-rates-cube-as-a-leader-for-semantic-layers). And - as to be expected - a Fast-Mover too. We’ve been launching new features left and right - in the last year [support for YAML](https://cube.dev/blog/introducing-cube-support-for-yaml-data-modeling), the [SQL API](https://cube.dev/blog/expanded-bi-support), the [Data Graph](https://cube.dev/blog/introducing-data-graph), the [Orchestration API](https://cube.dev/blog/introducing-orchestration-api), [Semantic Layer Sync](https://cube.dev/blog/introducing-semantic-layer-sync), and [Integrations with Langchain](https://cube.dev/blog/introducing-the-langchain-integration) and [other AI tools (Delphi!)](https://cube.dev/blog/conversational-interface-for-semantic-layer) - so are excited to be recognized for all the hard work. 

## But why does it matter? Understanding the Significance of Semantic Layers

Semantic layers and metrics stores play a pivotal role in the world of data analysis. They act as bridges between raw data and actionable insights, enabling organizations to harness the full potential of their data. A semantic layer, in particular, consolidates complex data into a format that is understandable across different teams and tools, effectively translating raw data into common business terms.

## Why Cube Stands Out

GigaOm noted several compelling reasons that made Cube standout: 

**Code-First Orientation**: Cube's [strong code-first orientation](https://cube.dev/docs/product/introduction#code-first) is a distinguishing feature. We firmly believe that the future of data engineering lies in applying proven software engineering practices - such as version control, code reviews, infrastructure testing -  to data management.  This will lead not only to data engineers having very granular control over the semantics of their data, but also structure these data models for reusability and maintainability. However, we also know that being able to work with data models with a GUI (graphical user interface) is also sometimes preferred. That’s why we combine the best of both worlds to allow data engineers to be code-first but the ability to jump into a GUI-based experience - like our recently launched [Data Graph](https://cube.dev/blog/introducing-data-graph). We are happy that GigaOm agrees.  

**All the APIs**: Cube's native API support ensures seamless integration with various data sources and analytics tools, making it a versatile choice for organizations with diverse tech stacks. We offer both data APIs -  - GraphQL, REST API, and SQL API - as well as the Orchestration APIs and monitoring integrations to not only send modeled data to whatever data experience your users want, but also integrate Cube monitoring and observability into all the usual DevOps tools.  

**Analytics Pre-Processing**: Cube's ability to perform analytics pre-processing through caching and pre-aggregations is a significant advantage that many competitors miss. This is especially critical in embedded analytics use cases where a data engineer is creating analytics for their customers. While it might be OK for an employee to wait for a minute or two when generating insights, it is never OK for a customer to wait even a nanosecond longer than necessary. And with Cube, customers can speed up queries from minutes to seconds - and seconds to sub-seconds - even with large datasets.

**Check out our position on their sonar report.**
![](https://ucarecdn.com/d266a78b-3dcf-4355-a59d-17a15007afa1/) 

**Yes. We’re a Platform, Not Just a Feature**
We love that Gigaom recognized us as a platform play vs. just a feature, as we believe that having a semantic layer will become a necessity for all data stacks in the very near future. Only a company that has built a platform and is able to integrate with any data source and any data experience - customer dashboards, BI tools, or even AI agents - will be able to serve as that missing piece of the data stack. 

**Beating the Big Brands**
Part of the advantage of having an open source version of Cube is that we have been able to grow faster with thousands of developers reviewing, adding, and using our code. How else were we able to leap ahead of SAP, Oracle, and even Google!? 

### What Else Might you Get from this Report

But if you want more than a glowing evaluation of Cube, you can find it in this report. GigaOm has provided plenty of information about semantic layers and how they fit into various organizations both big and small as well as real-world use cases to help drive home the need for one. Learn what to consider when you decide to adopt a semantic layer, how to make that decision, and how to implement it into your data stack with minimal interruptions.

### Get the Full Report and See for Yourself

For a comprehensive look at Cube's performance and a deeper dive into the world of semantic layers and metrics stores, we encourage you to read the complete GigaOm Sonar report. We [offer the report here for free](https://cube.dev/gigaom-rates-cube-as-a-leader-for-semantic-layers).

Jen Grant

All Things Cube

Hard Work Pays Off 

Cube recognized as a Leader and Fast-Mover in GigaOm’s Sonar for Semantic Layers

## Utilize the power and scalability of Snowflake.

We’ve long seen that the data experiences landscape has been very diverse. From dozens of general-purpose BIs to hundreds of vertical purpose-built analytical solutions, data consumers have many, many options to visualize and consume data.

The evolution of front-end technologies made it possible to embed quality analytics experiences directly into many software products, further accelerating the proliferation of data products and experiences. 

Cube works on top of Snowflake with direct queries and doesn’t require you to run extracts hence your data always remains in Snowflake. 

## What is a Semantic Layer?

A semantic layer is a middleware between your cloud data warehouse, such as Snowflake, and downstream applications. It abstracts raw data and presents it in a meaningful way to the end-user and serves as a contextual filter between the data warehouse and the various analytical tools that businesses use to slice, dice, and analyze their data.

![](https://ucarecdn.com/8d945f29-e9eb-4e7f-9e9e-29ae7074e195/)

## Why Cube and Snowflake?

**Future-proof data stack**. Snowflake established itself as the center of gravity in a **modern data stack**, a new approach to data engineering that enables teams to pursue higher-value activities. 

**Modern data stack** follows several foundational principles and architecture designs: 
* Using a cloud data warehouse like Snowflake as a central data platform
* [ELT vs. ETL](https://www.snowflake.com/guides/etl-vs-elt)
* Applying software engineering best practices to data management 

Cube embraces software engineering best practices and allows data engineers to [manage data model in code](https://cube.dev/docs/product/getting-started/cloud/create-data-model). This enables leveraging the version control systems to manage data model evolution safely and facilitate collaboration and code reviews. It also makes it possible to have a semantic layer as a part of the CI/CD process and have isolated environments for development, staging, and production.

**Utilize the power and scalability of Snowflake**. Cube works on top of Snowflake with direct queries and doesn’t require you to run extracts hence your data always remains in Snowflake. Cube pushes compute down to your Snowflake instance, fully utilizing the power and scalability of your cloud data warehouse. You can optionally create [pre-aggregations](https://cube.dev/docs/product/caching/getting-started-pre-aggregations) in Cube and enable aggregate awareness to not query your Snowflake instance with small repeated queries but rather update aggregates in the background.

## A step-by-step guide to building semantic layer with Cube and Snowflake

In the below section, we’ll cover a quickstart step-by-step tutorial on how to start with Cube and Snowflake. Cube Cloud is free to start, and you can sign up anytime. No credit card or calls with salespeople are required!

You can find a detailed getting started guide in Cube documentation. 

### Create Snowflake and Cube accounts
First, create Cube Cloud and Snowflake accounts.

If you don’t have a dataset that you would like to use, you can follow [this guide](https://cube.dev/docs/product/getting-started/cloud/load-data) to create a test dataset in your Snowflake instance.

### Connect Snowflake to Cube

Please follow these steps to create your first deployment in Cube Cloud and connect it to your Snowflake instance.

1. After you [sign in to your Cube Cloud account](https://cubecloud.dev/auth), click “Create Deployment”.

2. Give the deployment a name, select the cloud provider and region of your choice, and click “Next”.

3. Next, click Create to create a new project from scratch.
4. Select Snowflake from the list of supported data sources and enter your Snowflake credentials to connect to it. 
5. Once Snowflake is connected, Cube can generate a basic data model from your data warehouse schema, which helps you get started with data modeling faster. We'll inspect these generated files in the next section and start changing them.

### Create your data model
Cube follows a dataset-oriented data modeling approach, which is inspired by and expands upon dimensional modeling. 

When building a [data mode](https://cube.dev/docs/product/getting-started/cloud/create-data-model) in Cube, you work with two dataset-centric objects: cubes and views. Cubes usually represent business entities such as customers, line items, and orders. In cubes, you define all the calculations within the measures and dimensions of these entities. 

To begin building your data model, click on “Enter Development Mode” in Cube Cloud. This will take you to your personal developer space.

Once you are in developer mode, navigate to the “Data Model” and click on any file located in the left sidebar to open it.

You can follow [this detailed guide](https://cube.dev/docs/product/getting-started/cloud/create-data-model) on how to make changes to your data model and build new measures and dimensions.

When you are ready to test updates to your data model, you can navigate to [Cube’s Playground](https://cube.dev/docs/product/workspace/playground). The Playground is a web-based tool that allows you to query your data without connecting any tools or writing any code.

### Query your data
You can query Cube using a BI or visualization tool through the Cube SQL API. For a better experience, we recommend mapping the BI's data model to Cube's semantic layer. This can be done automatically with Semantic Layer Sync or manually.

**Semantic Layer Sync**
[Semantic Layer Sync](https://cube.dev/docs/product/getting-started/cloud/query-from-bi#semantic-layer-sync) will synchronize all public cubes and views with connected BI tools.
1. Create a new sync by navigating to the “Semantic Layer Sync” tab on the “BI Integrations” page and clicking “+ Create Sync”. 
2. Follow the steps in the wizard to create a sync
3. Replace the fields for user, password, and URL with your BI tool credentials, then click on “Save All”. You can now go to the “BI Integrations” page and trigger the synchronization of your newly created semantic layer.
4. After running the sync, navigate to your BI tool instance. You should see the orders_view dataset that was created in the tool. Cube automatically maps all metrics and dimensions in the BI tool to measures and dimensions in the Cube data model.

**Manual setup**
Alternatively, you can connect to Cube and create all the mappings manually. 
1. You can find the credentials to connect to Cube on the “BI Integrations” page under the “SQL API Connection” tab.
2. After connecting, create a new dataset in the BI tool and select "orders_view" as a table.
3. Now you can map the BI tool metrics and columns to Cube's measures and dimensions.

That was a high level preview. You can create both you Snowflake and Cube instance for free to try it out in your own environment.

### ...and you are ready to go...

The combination of Cube and Snowflake help to untangle the complexities of data modeling and empowers organizations to streamline their analytics efforts. Through step-by-step guidance, the blog has illuminated the path to creating a powerful semantic layer, enabling users to harness the true potential of their data and drive insightful decision-making. 

### More resources

Recorded workshop [Getting Started with Cube on Snowflake](https://cube.dev/events/unlock-data-cube-snowflake)

Detail on [connecting to Snowflake](https://cube.dev/docs/product/configuration/data-sources/snowflake)


Getting Started with a Snowflake Semantic Layer 

[Cube Core](https://github.com/cube-js/cube) releases v0.33.0 thru v0.33.43 bring a few important integrations: *DuckDB*, one of the most performant and definitely the most hyped OLAP database, and *LangChain*, the toolkit of choice for many developers of AI applications.

Additionally, we deprecate the `running_total` measure type in favor of a more generic and powerful `rolling_window` option.

## LangChain integration

Cube presents the integration with LangChain, the most popular toolset for building AI-based applications. It comes as the [document loader](https://python.langchain.com/docs/integrations/document_loaders/cube_semantic) that is intended to be used to populate a vector database with embeddings derived from the data model of the semantic layer. Later, this vector database can be queried to find best-matching entities of the semantic layer. This is useful to match free-form input, e.g., queries in a natural language, with the views and their members in the data model.

![diagram](https://ucarecdn.com/32e98c8b-a920-4620-a8d2-05d57618db8e/)

With this integration, builders of AI experiences can have a user-friendly, error-prone, and [hallucination-free](https://cube.dev/blog/semantic-layer-the-backbone-of-ai-powered-data-experiences) access to data. See the video for an example of experience one can build with this integration:

<video width="100%" controls><source src="https://ucarecdn.com/5500be7a-ab78-4de8-abc9-02df575ad3e0/video.mp4" type="video/mp4"/></video>

[Read more](https://cube.dev/blog/introducing-the-langchain-integration) in the announcement and [check the documentation](https://cube.dev/docs/product/configuration/visualization-tools/langchain) for details.

## DuckDB support

Cube expands the list of supported [query engines](https://cube.dev/docs/product/configuration/data-sources#query-engines) with [DuckDB](https://duckdb.org), an extremely performant in-process SQL OLAP database management system, and [MotherDuck](https://motherduck.com), a cloud service providing hybrid execution for DuckDB. With this integration, Cube can query data stored as Parquet, CSV, or JSON files at S3-compatible object storage servers, i.e., AWS S3, Google Cloud Storage, and Cloudflare R2.

![](https://ucarecdn.com/4fbb7247-379c-48a3-b298-0d87922e2531/)

You can easily go from local ad-hoc data exploration with DuckDB to building code-first data models and consistent metrics usable by everyone in an organization with Cube:

<video width="100%" controls><source src="https://ucarecdn.com/27491295-18eb-4d79-9b12-2db055a1b43f/video.mp4" type="video/mp4"/></video>

[Read more](https://cube.dev/blog/introducing-duckdb-and-motherduck-integrations) in the announcement and [check the documentation](https://cube.dev/docs/product/configuration/data-sources/duckdb) for details.

## `running_total` deprecation

As of v0.33.39, the use of the `running_total` measure type is [deprecated](https://github.com/cube-js/cube/blob/master/DEPRECATION.md#running_total-measure-type) in favor of the [`rolling_window` option](https://cube.dev/docs/product/data-modeling/reference/measures#rolling_window) that is more flexible and general-purpose. The semantics of `running_total` can be achieved by using `rolling_window` with the `trailing` option set to `unbounded`.

See the code example:

```yml
cubes:
  - name: example
    # ...

    measures:
      # Deprecated
      - name: total_amount
        sql: amount
        type: running_total

      # Recommended
      - name: total_amount
        sql: amount
        type: sum
        rolling_window:
          trailing: unbounded
```

## What’s next in Cube Core

We're just a few weeks away from Cube Core v0.34 with the support for snake_case in the configuration as well as writing the configuration entirely in Python in a `cube.py` file. Moreover, the v0.34 release will bring dynamic data models in YAML with Jinja and Python.

You can try Cube Core v0.33.43 today in Cube Core with our Docker distribution. It's also available on the latest release channel in [Cube Cloud](https://cubecloud.dev/auth/signup).

As always, please don't hesitate to [get in touch](https://cube.dev/contact) with us and share your feedback in our [Slack community](https://slack.cube.dev) of more than 8,500 data practitioners.

Integrations with two most popular tools of 2023 so far

Cube Core v0.33.43 — DuckDB support, LangChain integration

For many years already, we live in the data-driven world where accessing the data and deriving insights from it efficiently is paramount. This year, we experience an explosion of interest to artificial intelligence (AI) and large language models (LLMs) in particular, fueled by the latest developments in the technology and vast perspectives unfolding.

[LangChain](https://www.langchain.com), an extensive toolkit for working with LLMs, has become one of the most important building blocks for developers of AI experiences. At Cube, we know that our semantic layer is also an important building block for AI applications because Cube not only centralizes metrics calculations but also serves an [antidote to AI hallucinations](https://cube.dev/blog/semantic-layer-the-backbone-of-ai-powered-data-experiences).

## Semantic document loader

Today, we're happy to present Cube's integration with LangChain. It comes as the [document loader](https://python.langchain.com/docs/integrations/document_loaders/cube_semantic) that is intended to be used to populate a vector database with embeddings derived from the data model of the semantic layer. Later, this vector database can be queried to find best-matching entities of the semantic layer. This is useful to match free-form input, e.g., queries in a natural language, with the views and their members in the data model.

![diagram](https://ucarecdn.com/32e98c8b-a920-4620-a8d2-05d57618db8e/)

We're also providing an chat-based demo application (see [source code](https://github.com/cube-js/cube/tree/master/examples/langchain) on GitHub) with example [OpenAI prompts](https://github.com/cube-js/cube/blob/master/examples/langchain/utils.py#L48,L87) for constructing queries to Cube's [SQL API](https://cube.dev/docs/product/apis-integrations/sql-api). If you wish to create an [AI-powered conversational interface](https://cube.dev/blog/conversational-interface-for-semantic-layer) for the semantic layer, functioning similar to [Delphi](https://www.delphihq.com), these prompts can be a good starting point.

## Chat-based demo app, dissected

Here's what you can build with the all-new document loader for LangChain, a vector database, an LLM by [OpenAI](https://openai.com), and [Streamlit](https://streamlit.io) for the user interface:

<video width="100%" controls><source src="https://ucarecdn.com/5500be7a-ab78-4de8-abc9-02df575ad3e0/video.mp4" type="video/mp4"/></video>

See how the tables, columns, aggregations, and filters in the SQL query generated by an LLM match the human input. Check the [README file on GitHub](https://github.com/cube-js/cube/blob/master/examples/langchain/README.md) for pointers on running this demo application on your machine or skim through the following highlights.

**Ingesting metadata from Cube and populating the vector database.** The `ingest_cube_meta` function in the `ingest.py` file loads the data model from Cube using the all-new `CubeSemanticLoader`. Note that only [views](https://cube.dev/docs/product/data-modeling/reference/view) are loaded as they are considered the ["facade" of the data model](https://cube.dev/blog/complementing-data-graph-with-views). Loaded documents are then embedded and saved in the FAISS vector store, which is subsequently pickled for later use.

```python
def ingest_cube_meta():
    ...
    loader = CubeSemanticLoader(api_url, api_token)
    documents = loader.load()
    ...
    with open("vectorstore.pkl", "wb") as f:
        pickle.dump(vectorstore, f)
```

**LLM setup.** In the `main.py` file, dependencies are imported and the environment variables are loaded. The OpenAI model (`llm`) is initialized with the provided API key.

```python
import ...
load_dotenv()
llm = OpenAI(
    temperature=0, 
    openai_api_key=os.environ.get("OPENAI_API_KEY"),
    verbose=True
)
```

**User input and vector store initialization.** In the same file, Streamlit primitives are utilized to get user input:

```python
question = st.text_input(
    "Your question: ",
    placeholder="Ask me anything ...",
    key="input"
)
if st.button("Submit", type="primary"):
    check_input(question)
    vectorstore = init_vectorstore()
```

**Querying the vector store.** The vector store is queried for documents similar to the user's question. The best match's table name is extracted and taken as the best guess to try to create a prompt using the columns from vectorstore:

```python
docs = vectorstore.similarity_search(question)
    # take the first document as the best guess
    table_name = docs[0].metadata["table_name"]

    # Columns
    columns_question = "All available columns"
    column_docs = vectorstore.similarity_search(
        columns_question,
        filter=dict(table_name=table_name),
        k=15
    )
```

**Building the prompt and calling OpenAI.*** The OpenAI large language model is called with the constructed prompt, and the response is parsed to extract the SQL query and any associated filters:

```python
# Construct the prompt
prompt = CUBE_SQL_API_PROMPT.format(
    input_question=question,
    table_info=table_name,
    columns_info=columns,
    top_k=1000,
    no_answer_text=_NO_ANSWER_TEXT,
)
llm_answer = llm(prompt + PROMPT_POSTFIX)
```

![](https://ucarecdn.com/1252fc98-75db-4887-be82-227b60d477a9/)

## Wrapping up

Cube's integration with LangChain provides a seamless interface for querying data using natural language. By abstracting the complexities of SQL and leveraging the power of LLMs, it provides the builders of AI experiences with a user-friendly and error-prone approach to data access.

<Quote authorName="Josh Patterson" authorAvatar="https://media.licdn.com/dms/image/C4E03AQEdLbPJvBTgBg/profile-displayphoto-shrink_800_800/0/1517680131555?e=1697673600&v=beta&t=CVQuMtVDphwPh1WwLOb_OJ0qBHZqHEJmDCcM6GJIYzo" authorRole="CEO at Patterson Consulting">

It is essential for enterprises to leverage internal knowledge correctly with the power of LLM’s reasoning. Cube’s semantic layer integration with LangChain is a great example of how most product companies will eventually write smart integrations for LLMs to better power these reasoning engines.

</Quote>

Our partners at Patterson Consulting have been hard at work building with Cube, LangChain and LLMs. They have written a wonderful ebook as a primer to [Building Enterprise Applications with LLMs](https://pattersonconsultingtn.com/content/intro_to_llms_ebook.html).

**You can try the LangChain integration with a Cube Core or [Cube Cloud deployment](https://cubecloud.dev/auth/signup) today.** Join our Slack community at [slack.cube.dev](https://slack.cube.dev) to share your thoughts and opinions about this update.

Mikhail Nitsenko

Artificial Intelligence

Powerful tooling for building AI experiences with LLMs and the semantic layer

Introducing the LangChain integration

Today, we're happy to announce Cube's integrations with [DuckDB](https://duckdb.org), an extremely potent in-process SQL OLAP database management system, also known as "the most hyped thing in data in 2023 prior to the AI craze", and [MotherDuck](https://motherduck.com), a cloud service providing hybrid execution for DuckDB, i.e., offloading some computations to the cloud and merging the results locally.

We see vast advantages for users of Cube, the semantic layer, and DuckDB, the super-fast OLAP database, in using them together. Let's unpack the use cases and explore the benefits.

## Built-in query engine

Since DuckDB is an in-process OLAP DBMS, the integration with Cube implies bundling DuckDB together with Cube. Indeed, now every Cube Core or [Cube Cloud](https://cube.dev/product/why-cube-cloud) deployment comes with a built-in and instantly available DuckDB which has the [HTTPFS](https://duckdb.org/docs/extensions/httpfs) extension installed and loaded by default. With this extension, DuckDB can directly query Parquet, CSV, and JSON files over HTTPS, including files on S3-compatible object storage servers like AWS S3, Google Cloud Storage, and Cloudflare R2.

![](https://ucarecdn.com/d3e42677-83ce-4ad8-8ac9-c39d3b74e252/)

With built-in DuckDB, your semantic layer now has direct access to semi-structured data in a data lake or object storage without the need for any intermediary tools, e.g., an additional [query engine](https://cube.dev/docs/product/configuration/data-sources#query-engines) between your data and your semantic layer. You still can do this in complex scenarios, but DuckDB helps get you started in almost no time.

![](https://ucarecdn.com/4fbb7247-379c-48a3-b298-0d87922e2531/)

You can also connect DuckDB to MotherDuck and get hybrid execution for your queries, so that MotherDuck will do all the heavy lifting querying the data from remote storage.

## Value-add semantic layer

In lots of excitement about DuckDB, one could always spot a bit of scepticism about its intended production use. No doubt DuckDB is a fantastic and super-fast tool for local data exploration and experimentation—but what should be the next step to share the results with the team or stakeholders and put the insights into use? (We know one can always send an Excel sheet over email but it's so ad-hoc and so *not* 2023, right?)

Now, you can go from a quick analysis in a local DuckDB instance accessible to you and you only to a governed metric in a semantic layer accessible across the whole organization in a single step. As soon as you're happy with the metric definition and the results it yields, you can move the definition into Cube's code-first data model. It will take seconds to enter the [development mode](https://cube.dev/docs/product/workspace/data-model), update the data model, test the result, and roll out an updated metric into production without any disruption to existing data consumers.

<video width="100%" controls><source src="https://ucarecdn.com/27491295-18eb-4d79-9b12-2db055a1b43f/video.mp4" type="video/mp4"/></video>

In the demo video above, a Parquet file with 16 million rows and 250 MB in size, residing in a Google Cloud Storage bucket, is queried using a local DuckDB (left) and MotherDuck (right). You can see that MotherDuck drastically outperforms local DuckDB when querying remote files. You can also see that moving from an analytical query against DuckDB or MotherDuck to a metric defined in the semantic layer and available to all data consumers is a matter of seconds.

## Next steps

Just like the MotherDuck team, we'd love to see how you'd put the power of DuckDB and MotherDuck into a production use with Cube:

<Quote authorName="Ryan Boyd" authorAvatar="https://ucarecdn.com/fde84267-5173-4577-80a4-b9291f205f3e/" authorRole="Co-Founder at MotherDuck">
Pairing the universal semantic layer of Cube with the hybrid execution of MotherDuck allows users to easily go from local development to building code-first data models and consistent metrics that keep everyone in an organization on the same page.
</Quote>

**In October, we’re co-hosting a webinar with the MotherDuck team.** Please stay tuned for the webinar registration; we'd love to show you live how Cube and DuckDB work together.

**DuckDB and MotherDuck integrations are available in Cube Core and Cube Cloud, and you can [try them today](https://cubecloud.dev/auth/signup).** Join our Slack community at [slack.cube.dev](https://slack.cube.dev) to share your thoughts and opinions about this update.

Query Engines

Semantic layer meets a duck on top of a data lake

Introducing DuckDB and MotherDuck integrations

Two months ago, we [introduced Data Graph](https://cube.dev/blog/introducing-data-graph) in Cube Cloud as a human-friendly, visual way to explore contents of the semantic layer.

Data Graph aims to represent the data model as an [entity relationship diagram](https://en.wikipedia.org/wiki/Entity–relationship_model) and it's the best way to take a bird’s-eye view of the data model and familiarize oneself with the contents of a semantic layer. Initially, Data Graph only visualized [cubes](https://cube.dev/docs/product/data-modeling/reference/cube), allowing data engineers to explore join relationships and find clusters of interconnected cubes.

Today, we're proudly adding the visualization of [views](https://cube.dev/docs/product/data-modeling/reference/view) to Data Graph.

![Data Graph with views](https://ucarecdn.com/a67295d5-c3c0-48a4-8a16-564b202ad603/)

## Views in Data Graph

Views sit on top of the graph of cubes and create a facade of your whole data model with which data consumers can interact. Views are useful for defining metrics, managing governance and data access, and controlling ambiguous join paths.

![](https://ucarecdn.com/bfc3e04a-b690-40bc-a6f8-14a9175fb4fd/)

We recommend that all cubes should be made non-public (thus, not exposed to data consumers); instead, views should be defined on top of cubes and exposed to BIs, data applications, etc.

Now, data engineers working with the data model of the semantic layer can define views with the code-first approach using [YAML syntax](https://cube.dev/docs/product/data-modeling/fundamentals/syntax#model-syntax) and use Data Graph to explore the end result: review join paths between cubes referenced in a view, see the lineage of view members, and check their types and visibility.

<video width="100%" controls><source src="https://ucarecdn.com/f4b0f37c-4a46-49fb-865f-7da96a093544/datagraphviews.mp4" type="video/mp4"/></video>

## What's next?

We've got some positive and insightful feedback from early Data Graph users. Still, we’d like to hear more of your feedback to ensure that Data Graph is indeed the ultimate way to explore the full data model of the semantic layer.

__Data Graph is available in Cube Cloud on [all tiers](https://cube.dev/pricing), and [you can try it today](https://cubecloud.dev/auth/signup).__ Check that your deployment uses version 0.32.30 or above and give Data Graph a spin. Also, please join our Slack community at [slack.cube.dev](https://slack.cube.dev) to share your thoughts and opinions about Data Graph.

Ultimate way to explore the full data model of the semantic layer

Complementing Data Graph with views

In today's digital landscape, the ability to extract valuable insights from data is a key differentiator for businesses. [Data modeling](https://cube.dev/product/data-modeling), the art of structuring data to facilitate analysis and decision-making, plays a pivotal role in this process. Various data modeling techniques cater to different data scenarios, each with its own unique strengths and applications. 

So today, we'll explore diverse data modeling techniques along with real-world use cases. Additionally, we'll discuss how the implementation of a semantic layer, often in the form of a cube, can enhance data modeling capabilities.

## Data Modeling Techniques

### Entity-Relationship (ER) Modeling

The Entity-Relationship (ER) model is a foundational technique that depicts entities, attributes, and relationships between them. ER modeling is particularly useful in conceptualizing complex systems and defining logical database structures.

__Example:__

In a healthcare setting, ER modeling can help represent patient records. Entities might include Patients, Doctors, and Medications. Attributes for Patients could encompass Name, Age, and Medical History. Relationships such as "Treated By" would link Patients to Doctors.

### Relational Data Modeling

Relational Data Modeling is centered around tables, rows, and columns, forming the basis for relational databases. This technique is well-suited for structured data that adheres to well-defined schemas.

__Example:__

For a banking system, relational modeling can organize customer data into tables such as Customers and Accounts. The Customers table might hold personal information, while the Accounts table would detail account balances and transaction history.

### Dimensional Data Modeling

Dimensional modeling, integral to data warehousing and business intelligence, involves creating fact and dimension tables. This technique simplifies complex data structures to expedite querying and reporting.

__Example:__

In retail analytics, a dimensional model could encompass a Sales Fact Table connected to Dimensions like Time, Product, and Location. This configuration enables easy analysis of sales trends over specific time periods, for specific products, and in specific regions.

### Object-Oriented Data Modeling

Object-Oriented Data Modeling extends programming principles to data representation. It treats data as objects with attributes and behaviors, suitable for modeling complex relationships and dynamic systems.

__Example:__

In a manufacturing context, object-oriented modeling could represent a production line. Objects might include Machines, Products, and Workers. Relationships could depict how Workers operate Machines to create Products.

### NoSQL Data Modeling

NoSQL databases embrace flexible schema designs, accommodating unstructured and semi-structured data. Different NoSQL data models include document, key-value, column-family, and graph.

__Example:__

A content management system might use a NoSQL document model to manage articles. Each document could house diverse attributes such as Title, Author, and Content, catering to the varying nature of content pieces.

### Graph Data Modeling

Graph data modeling is perfect for capturing intricate relationships among entities. It's prevalent in social networks, recommendation systems, and fraud detection.

__Example:__

In a social network, a graph model could map users as nodes and friendships as edges. This enables efficient representation of connections and helps the platform suggest potential friends to users.

### Physical Data Modeling

Physical Data Modeling focuses on database implementation, specifying data types, indexes, and constraints. It bridges the gap between conceptual models and actual databases.

__Example:__

For a logistics company, physical data modeling might involve designing tables to store shipment details. Attributes like Sender, Recipient, and Delivery Date could be defined, and indexes could be set up for faster tracking of shipments.

## The Power of Semantic Layers in Data Modeling

A [semantic layer](https://cube.dev/use-cases/semantic-layer), often implemented through tools like [Cube](https://cube.dev/) (that's us, hello!), acts as a bridge between raw data and end-users, significantly enhancing the data modeling process. 

Let's see how:

### Simplification

Semantic layers abstract the complexities of underlying data structures. With Cube, complex SQL queries and data transformation processes are hidden behind a simplified interface, allowing business users to interact with data effortlessly.

### Performance Optimization

Semantic layers like Cube pre-aggregate data, reducing the load on source databases and enhancing query performance. This optimization leads to faster response times and a smoother user experience.

### Consistency and Standardization 

A semantic layer ensures consistency in data interpretation across the organization. When using Cube, business users rely on a unified view of data, reducing the chances of misinterpretation and errors.

## To sum it up

Data modeling techniques are the cornerstones of effective data management and analysis, catering to diverse data scenarios and organizational needs. 

From ER modeling for complex relationships to NoSQL models for unstructured data, each technique offers a unique approach to structuring information. Additionally, the integration of a semantic layer, often manifested as a cube, enhances data accessibility and usability, providing a structured yet user-friendly way to interact with complex datasets. 

And, by choosing the right data modeling technique and leveraging the power of semantic layers, organizations can harness their data's full potential, unlocking insights that drive strategic decision-making and innovation.

Curious about how a semantic layer can boost your data modeling? [Reach out to us](https://cube.dev/contact)—we'd love to talk!


Tamar Barlev

Data Engineering

The what, how, and why of Data Modeling.

Data Modeling Techniques 101

In our superbly data-obsessed world, information is the lifeblood of successful businesses. Therein, the challenge lies in harnessing data's true potential, which has historically been a challenging endeavor for many companies. 

Enter data democratization: a revolutionary concept that has the power to transform organizations, streamline decision-making processes, and unlock innovation. 

And so, today, we'll explore what data democratization means, delve into real-life examples of the problems that arise without it, and highlight its importance across different kinds and sizes of companies. 

## What is Data Democratization?

Data democratization is the process of making data accessible to all relevant stakeholders across an organization, regardless of their technical expertise. 

Traditionally, data was restricted to specialized teams or individuals, leading to bottlenecks, silos, and slower decision-making. Data democratization breaks down these barriers by empowering employees at all levels to access, interpret, and leverage data in their daily operations. 

By promoting a culture of data sharing and collaboration, companies can transform data from a mere resource to a strategic asset.

## …With*out* Data Democratization:

Without data democratization, companies face several challenges that can hinder their growth and competitiveness, such as:

* **Lack of insights:** siloed data inhibits the ability to gain comprehensive insights into business operations. Important correlations and trends may be overlooked, leading to missed opportunities.
* **Sluggish decision-making:** relying on a select few to analyze and interpret data slows down the decision-making process. Real-time data is crucial for making agile and informed decisions.
* **Innovation blockade:** when data is limited to a select group, innovative ideas are stifled. The lack of diverse perspectives and cross-functional collaboration hinders the emergence of breakthrough solutions.

## …*With* Data Democratization

Conversely, companies that embrace data democratization experience a multitude of benefits, including (but not limited to):

* **Faster Decision-Making**: with [business intelligence](https://cube.dev/blog/building-business-intelligence-dashboards-your-team-will-actually-want-to) and general data readily available to all employees, decisions can be made swiftly and based on up-to-date information.
* **Enhanced Productivity**: empowering employees to access and analyze data directly reduces their dependency on data specialists, freeing up valuable time and resources.
* **Informed Innovation**: when every team member has access to data, it fosters a culture of innovation, where creative solutions can emerge from unexpected places.
* **Improved Customer Experience**: by enabling front-line employees to access customer data, companies can deliver more personalized and tailored experiences, leading to increased customer satisfaction.
* **Better Strategic Planning**: data-driven insights are essential for formulating effective strategies and adapting to dynamic market conditions.

## Actual applications of the abstract concept

There _are_ studies, too; for instance, a [McKinsey study](https://www.mckinsey.com/capabilities/mckinsey-digital/our-insights/the-need-to-lead-in-data-and-analytics) found that 64% of respondents from high-performing organizations reported that “data is accessible across the organization,” as opposed to 33% from low-performing organizations. But let's dig into some practical benefits of this otherwise fluffy-sounding concept.

### 1. Empowering Employees with Self-Service Analytics

Data democratization allows employees from various departments, including marketing, sales, finance, and operations, to access and explore data on their own. [Self-service analytics](https://cube.dev/blog/the-future-of-self-service-analytics-data-driven-decisions-meet) tools provide an intuitive interface that enables non-technical users to create reports, perform analyses, and generate insights without relying on data specialists or IT teams. This empowers employees to make data-driven decisions in real-time, reducing the dependency on a limited group of data experts and accelerating problem-solving.

### 2. Enhanced Collaboration and Cross-Functional Insights

In traditional data setups, data is often siloed within departments, hindering collaboration and limiting access to valuable insights. With data democratization, employees from different functions can access a unified data repository, fostering cross-functional collaboration. This collaboration enables a more comprehensive understanding of business operations and allows teams to identify dependencies, correlations, and opportunities that might have been missed in isolated data sets.

### 3. Better Customer Understanding and Personalization

Understanding customers and delivering personalized experiences is crucial for businesses in today's competitive landscape. Data democratization enables customer-facing teams, such as sales and customer support, to access customer data, transaction history, and preferences. Armed with this knowledge, they can tailor interactions, anticipate needs, and provide personalized solutions, leading to improved customer satisfaction and loyalty.

### 4. Real-time Decision Making

In fast-paced business environments, the ability to make decisions quickly is essential. Data democratization enables access to real-time data, which is vital for making agile decisions based on the latest market trends, customer behavior, or operational performance. Real-time insights allow companies to respond promptly to changing conditions and gain a competitive edge.

### 5. Identifying New Business Opportunities

Data democratization facilitates a culture of innovation and empowers employees to explore data creatively. By encouraging every employee to analyze data, companies can surface new ideas and identify potential business opportunities that might otherwise remain hidden. A diverse set of perspectives and innovative ideas can emerge, driving growth and setting the stage for future success.

### 6. Improved Data Quality and Governance

Data democratization does not mean a free-for-all approach to data access. Rather, it promotes responsible data usage through proper governance and data quality standards. By establishing clear data governance policies and roles, companies can ensure data accuracy, consistency, and security. This, in turn, enhances data trustworthiness and safeguards against erroneous decisions based on inaccurate information.

### 7. Competitive Advantage and Business Growth

Data-driven decision-making is a key differentiator in today's market. Companies that embrace data democratization can quickly turn insights into action, making them more adaptable and agile. This ability to respond rapidly to market changes and customer needs gives them a competitive advantage, propelling business growth and expansion.

### 8. Enhancing Data Literacy and Skills

Data democratization fosters a data-driven culture within organizations, leading to increased data literacy among employees. As more individuals engage with data and analytics tools, their analytical skills improve, driving a shift towards a data-centric mindset. This upskilling of the workforce ensures that data-driven insights become an integral part of daily operations.

### 9. Optimizing Resource Allocation

With data democratization, companies can optimize resource allocation by identifying inefficiencies and areas of improvement. Data insights enable organizations to allocate their budgets, time, and workforce more strategically, ensuring that resources are directed where they can have the most significant impact.

## Data Democratization: important across the board

Data democratization is not limited to any particular industry or company size. Its significance spans across various sectors, including startups, small and medium-sized enterprises (SMEs), and large enterprises.

In the early stages, startups require data to validate their assumptions, identify target markets, and refine their business models. Democratizing data from the outset empowers them to make crucial decisions that can determine their success.

Next up: SMBs. Installing a data-driven culture enabled by data accessibility, smaller businesses can level the playing field and to compete with larger rivals on customer understanding.

And, in large, complex organizations, data is often scattered across multiple departments. Data democratization unifies the organization, ensuring everyone has access to the same information, leading to cohesive strategies and streamlined operations.

## The Role of the Semantic Layer

To effectively implement data democratization, companies can hugely leverage a universal semantic layer, which acts as a bridge between the raw data and end-users. 

A universal semantic layer provides a unified view of the data, abstracting its complexities and making it easily accessible to all employees, and thereby accomplishes several key tasks in installing data accessibility:

1. **Data Abstraction**: the semantic layer hides the technical details and complexities of the underlying data sources, enabling non-technical users to interact with the data effortlessly.
2. **Data Governance**: by defining clear data access permissions and policies in a centralized manner, immediately downstream of data sources, the semantic layer ensures that sensitive information is only accessible to authorized users. This cohesive governance preserves data security and compliance.
3. **Self-Service Analytics**: With a semantic layer in place, employees can use intuitive tools and interfaces to explore and analyze data without requiring specialized technical skills. Companies can use [a myriad of tools](https://cube.dev/blog/the-critical-components-an-example-embedded-analytics-tools-stack), from out-of-the-box BI and notebooks to super customizable front-end libraries, in order to give employees a precisely tailored data experience. 
4. **Consistency and Accuracy**: The semantic layer ensures consistent data definitions and terminology throughout the organization, by defining metrics upstream of every data application in the company’s stack. Doing so eliminates cross-collaborative confusion and errors resulting from inconsistent data interpretations and keeps everyone on the same page.
5. **Time-to-value**: when everything data-orchestration is taken care of once, upstream of every data application, it makes it a lot easier (and just generally feasible) for teams to build the right data experiences for them.  

## To sum it up

Data democratization is not just a buzzword; it's a transformative approach that empowers companies to unleash their true potential. By breaking down data silos and fostering a data-sharing culture, companies can make more informed decisions, foster innovation, and deliver better customer experiences. 

And, leveraging a semantic layer as part of this democratization process enhances accessibility, data governance, and overall data-driven decision-making, enabling companies to thrive in a data-driven world. Embrace the power of data democratization and witness the remarkable transformation it can bring to your company.

Curious how a semantic layer can empower your organization to move towards data democratization? [Reach out to us](https://cube.dev/contact)—we’d love to talk :) 


Best Practices

Or, how to unleash your company's potential.

The Importance of Data Democratization

Data pipelines, data modeling, and BI tools to collect, store, and analyze data at scale.

Front-end applications and low-code tools to bring data insights to end users.

Application Development

Company news, product updates, and engineering deep dives.

Latest news and insights from Cube

Data Engineering

Application Development

All Things Cube

Getting Started with a Databricks Semantic Layer

Cube Cloud update — Tableau in Semantic Layer Sync, Views in Data Graph, and Budgets

Introducing Semantic Layer Sync with Tableau

Cube Cloud Now Available on the AWS Marketplace

Cube recognized as a Leader and Fast-Mover in GigaOm’s Sonar for Semantic Layers

Get Cube updates to your inbox

Getting Started with a Snowflake Semantic Layer

Cube Core v0.33.43 — DuckDB support, LangChain integration

Introducing the LangChain integration

Introducing DuckDB and MotherDuck integrations

Upgrade your data stack today

Complementing Data Graph with views

Data Modeling Techniques 101

The Importance of Data Democratization

Data Engineering

Application Development

All Things Cube