Collaborative data analytics notebooks for teams and analysts
Hex is a collaborative data & analytics notebook platform combining SQL, Python, and R in shareable interactive reports and dashboards; it suits data teams and analysts who need reproducible, query-first workflows and embedded apps. Hex offers a usable Free tier for personal projects and seat-based paid plans for teams (pricing scales per user), making it practical for small teams and enterprises alike.
Hex is a collaborative data & analytics notebook platform that blends SQL, Python, and R into interactive reports and dashboards. It lets analysts run warehouse-backed queries, build visualizations, and turn notebooks into shareable apps. Hex’s key differentiator is notebook-first collaboration with row-level permissioning and direct warehouse pushdown, making it well suited for data teams, product analysts, and analytics engineers. The platform offers a Free tier for personal use and paid, seat-based plans that scale to teams and enterprises, enabling predictable per-user pricing and admin controls.
Hex is a data & analytics notebook and collaboration platform founded in 2020, positioned to bridge SQL-first analytics with modern data science workflows. Built for teams that rely on cloud data warehouses, Hex emphasizes reproducibility and operational analytics: notebooks can contain SQL queries, Python, and R cells that run against Snowflake, BigQuery, Redshift, and other warehouses. Hex’s product goal is to replace disconnected SQL editors, BI dashboards, and ad-hoc Python scripts with a single environment where analyses are versioned, documented, and easily shared with stakeholders.
Hex’s feature set focuses on pragmatic analytics capabilities. Notebooks support mixed-language cells (SQL, Python, R) and let users push SQL logic down to the warehouse for efficiency. Visualizations include a chart builder plus programmatic Vega support and the ability to create interactive parameterized components for end-users. Data connections include native connectors to Snowflake, BigQuery, Redshift, Postgres and S3, with credential management and query profiling. Collaboration features include shared projects, per-notebook permissions, version history and snapshotting, embedded dashboards, and scheduled runs to operationalize reports. Hex also exposes API endpoints and run tokens to trigger notebooks programmatically for automation use cases.
Pricing is tiered: Hex offers a Free tier with core notebook features for individuals; paid plans move to per-seat pricing with team and enterprise controls. The Free tier supports limited projects and public sharing appropriate for experimentation. Paid tiers (team/business) add private projects, unlimited viewers on dashboards, scheduled jobs, SSO and role-based access; enterprise adds audit logs, dedicated support, and custom contracts. Exact paid prices vary by seat count and billing cadence; Hex lists contact options for enterprise negotiation and often requires annual commitments for larger deployments (prices noted here are approximate; consult hex.tech/pricing for current figures).
Hex is used by analytics engineers and data teams to produce reproducible analyses and production dashboards. Example users include a Product Analyst using Hex to deliver interactive cohort analyses and reduce ad-hoc report time from days to hours, and an Analytics Engineer using Hex to codify ETL validation checks and push query logic to Snowflake. Teams also embed Hex apps into internal portals for ops dashboards. In many workflows Hex competes with Mode for SQL-first analytics and Observable for interactive visual notebooks, but Hex skews toward warehouse pushdown and seat-based team governance.
Three capabilities that set Hex apart from its nearest competitors.
Current tiers and what you get at each price point. Verified against the vendor's pricing page.
| Plan | Price | What you get | Best for |
|---|---|---|---|
| Free | Free | Limited projects, public sharing, personal workspace, community support | Individuals experimenting and learning Hex |
| Team | $18/mo/user (approx.) | Private projects, scheduled runs, SSO, 5GB storage per user (approx.) | Small analytics teams needing governance |
| Business | $45/mo/user (approx.) | Unlimited viewers, audit logs, priority support, larger storage | Mid-size teams with security needs |
| Enterprise | Custom | Custom SLA, dedicated support, SSO & SCIM, advanced compliance | Large orgs requiring contract terms |
Copy these into Hex as-is. Each targets a different high-value workflow.
Role: You are an SQL engineer writing a warehouse-efficient query for Hex. Constraints: 1) Input table name events with columns user_id, event_time (timestamp), event_name; 2) Use a single SQL cell, avoid CTEs that prevent pushdown when possible; 3) Week starts on Monday, UTC. Output format: Provide a single parameterized SQL query that returns week_start (date), weekly_active_users, daily_active_users (optional column showing max DAU in that week). Example comment: -- replace events with my_schema.events. Include brief one-line explanation of counting approach and performance tip.
Role: You are a product analyst preparing a reusable Hex SQL cell. Constraints: 1) Provide a safe, parameterized SQL template using {{start_date}} and {{end_date}} placeholders; 2) Validate casting and default values so empty parameters fall back to last 30 days; 3) Include LIMIT and ordering to keep quick previews. Output format: Return only the ready-to-paste SQL with a short comment header explaining parameters and defaults. Example: -- start_date: 2024-01-01, end_date: 2024-01-31. No extra prose, only SQL and header comments.
Role: You are a product analyst building a 12-week retention cohort for Hex. Constraints: 1) Input table events(user_id, event_time, event_name); cohort defined by first purchase event named 'purchase'; 2) Output weekly cohorts for 12 weeks post-cohort; 3) Optimize for pushdown aggregation. Output format: Provide (A) SQL that produces columns: cohort_week_start, week_number, users_in_cohort, returning_users, retention_rate; (B) Example Hex Python/SQL cell snippet that renders a heatmap with cohort_week_start on y and week_number on x; (C) brief note about index/partition recommendations. Include one small example row set.
Role: You are an analytics engineer authoring a repeatable ETL test suite for Hex-run validations. Constraints: 1) Accept a single variable table_name; 2) Produce 6 tests: row_count change threshold, null-rate per critical column, unique key violation, referential integrity sample, column type drift, and max-lag check; 3) Format tests so they can be scheduled nightly and return rows when failing. Output format: JSON array where each element has keys: test_name, sql_query, failure_condition_description, severity. Include one concrete example using table_name=my_schema.orders and thresholds.
Role: You are an analytics/security engineer drafting row-level permission policies for Hex dataset access. Instructions: 1) Given roles: admin, data_analyst, sales_rep, and finance, and sample table schema orders(order_id, account_id, region, amount, owner_id), provide SQL filter expressions per role; 2) Admin sees all rows; data_analyst sees region IN (...) OR owner_id IS NULL; sales_rep sees owner_id = CURRENT_USER_ID placeholder; finance sees amount > 0 and region IN finance_regions; 3) Output format: JSON with role, sql_filter_expression, example_evaluation (one sample row and whether it would be visible). Provide two few-shot examples demonstrating evaluation. Also supply deployment steps for Hex dataset row-filter configuration.
Role: You are a data scientist building a Hex app to explore model predictions with live parameters. Multi-step instructions: 1) Provide a multi-cell Hex notebook blueprint: SQL cell to fetch feature rows with {{sample_date}} and {{customer_id}} parameters; Python cell to load model artifact from S3 and run predictions; Python cell to compute SHAP-like feature importances for a selected row; visualization cell to show prediction, probability, and feature contribution bar chart; deployment cell to expose parameters as app inputs. Output format: return numbered cells with code, parameter declarations, and a small example using customer_id=123 and sample_date=2025-01-01.
Choose Hex over Mode if you need notebook-style SQL+Python collaboration and embeddable parameterized apps for internal tooling.