Implementing Cube Dev typically follows a structured, developer-friendly process that can be completed in a few hours to a few days, depending on the complexity of your data and deployment environment. Here's a step-by-step overview:
Project Setup
Begin by creating a new Cube project locally or on Cube Cloud. For local setup, use Docker to scaffold a project directory and configure the docker-compose.yml file with Cube’s image and environment variables.
Start Development Server
Run docker compose up -d to launch the Cube development server. This initializes the Developer Playground at http://localhost:4000, where you can interact with your data.
Connect a Data Source
Use the Playground’s database connection wizard to link Cube to your data warehouse (e.g., PostgreSQL, BigQuery, Snowflake). Credentials are stored in an .env file automatically.
Generate Data Models
Select tables from your database and generate semantic data models in YAML or JavaScript. These models define measures, dimensions, and joins used in analytics.
Query and Test
Use the Developer Playground or Cube APIs (REST, GraphQL, SQL) to run queries and validate your models. You can also embed these queries into applications or BI tools.
Optimize with Pre-Aggregations
Add pre-aggregations to improve query performance. This step is crucial for scaling analytics and reducing latency.
Deploy to Production
For production, deploy Cube Core with Docker or use Cube Cloud for managed infrastructure. Configure caching, orchestration, and security settings as needed.
Cube Dev is highly customizable and designed to adapt to diverse business requirements across industries and use cases. Here are key customization capabilities:
Dynamic Data Modeling
Cube allows you to define data models programmatically using Python or JavaScript. You can customize measures, dimensions, joins, and SQL logic based on business rules or user roles.
Multitenancy Support
Cube supports per-tenant data models and data sources. You can configure different schemas, tables, or even databases for each tenant using context_to_app_id, repository_factory, and driver_factory functions.
Custom Access Control
Member-level access can be customized so that different users or tenants see only relevant parts of the data model. This is useful for SaaS platforms or organizations with strict data governance.
Environment-Based Configuration
Cube supports environment variables and runtime configuration files (cube.py or cube.js) for flexible deployment setups. You can dynamically rewrite queries, set cache behavior, and control orchestration settings.
Custom Driver and API Integration
You can implement custom data source drivers or integrate Cube with external APIs, cloud storage (e.g., S3), or databases to fetch and compile data models dynamically.
Custom Query Logic
The query_rewrite function lets you inspect and modify queries before execution, enabling advanced filtering, personalization, or compliance logic.
Cube Dev’s pricing is based on Cube Consumption Units (CCUs), which measure resource usage. There are no fixed setup fees for Cube Cloud, and users can start with a free tier that includes two developer instances and a 1,000-query daily limit.
For paid plans:
Support Charges vary by tier:
Maintenance is handled by Cube Cloud for managed deployments, eliminating infrastructure overhead for users.
Cube Dev offers a comprehensive onboarding experience through documentation, tutorials, and live support:
Cube Dev implements enterprise-grade security through its semantic layer and Cube Cloud platform:
Cube Dev releases updates frequently, with new versions of Cube Core and Cube Cloud rolled out every few weeks to months. These updates include performance improvements, new features, integrations, and security enhancements. For example, recent updates have introduced support for Power BI, LangChain integration, Python scripting, and Semantic Layer Sync.
Updates are managed through:
Cube Dev is designed with data ownership and portability in mind, especially for enterprise and multi-tenant environments. Key principles include:
Access Policies: Cube supports member-level and row-level access policies that can be customized per role, region, or user context. These policies are embedded in the data model and can be migrated or replicated across deployments.
Cube’s architecture ensures that businesses can move, replicate, or decommission Cube deployments without losing access to their data models or analytics logic.
Cube Dev offers flexible scaling options through Cube Cloud, allowing organizations to adjust resources based on demand:
Auto-Scaling API Instances: Cube Cloud supports automatic scaling of API instances. You can configure minimum and maximum limits based on query throughput (e.g., 1 instance per 5–10 requests/sec).
Cube’s architecture supports both horizontal scaling (more instances) and vertical scaling (more powerful instances), making it suitable for startups and large enterprises alike.
Cube Dev’s contract terms are governed by its Terms of Use. Key points include:
Cube Dev is SOC 2 Type I compliant, which means it has implemented controls to ensure the security, availability, processing integrity, confidentiality, and privacy of customer data. SOC 2 compliance is governed by the American Institute of CPAs (AICPA) and is a widely recognized standard for SaaS and cloud-based platforms.
Key compliance features include:
Cube Dev is working toward SOC 2 Type II certification, which will validate the effectiveness of these controls over time. While SOC 2 is the primary compliance standard currently met, Cube Dev also supports customer-managed encryption keys and BYOC (Bring Your Own Cloud) deployments for organizations with stricter compliance needs.
