Visivo vs Rill: Semantic Layer, Drafts, and Pricing

Visivo and Rill are both code-first BI tools. Both keep dashboards and metric definitions in files under version control, both have a local developer tool and a hosted cloud, and both have real AI features. The differences are in how each one models your data, how a change gets from an idea to production, and how the bill scales when more people need to see the numbers. Rill charges per seat. Visivo Platform is one flat price with unlimited members.

This post compares the two honestly, including where Rill is the better pick. Pricing was checked against each vendor's public pricing page on November 4, 2026.

Want to try Visivo while you read? Install the open source CLI with curl -fsSL https://visivo.sh | bash (or pip install visivo), or start free in Visivo Cloud with $30 of credit and no card.

The short version

• Pick Visivo if you want a semantic layer with declared joins across models, a draft-then-commit workflow for every edit, and a flat price that does not grow as you share dashboards with more people.
• Pick Rill if your core need is very fast slice-and-dice over large event data on an OLAP engine, your team is small (Rill's seat bill stays under Visivo's flat price up to 20 seats on Starter), or you need embedded analytics today.

Side by side

The semantic layer: joins as part of the model

Both tools agree that a metric should be defined once. They differ on where joins live.

In Rill, a metrics view defines dimensions and measures on top of a single model or table. If a measure needs data from two tables, you join them upstream in model SQL and point the metrics view at the result. Rill's own guidance leans toward a "one big table" design. That is a fast, proven pattern for event analytics, and it suits Rill's OLAP engine.

In Visivo, the semantic layer has three parts. Metrics are aggregate definitions. Dimensions are row-level fields. Relations declare how models join. Declare a relation once, and an insight can put a metric from one model against a dimension from another without anyone writing that join again:

sources:
  - name: warehouse
    type: duckdb
    database: local.duckdb

models:
  - name: orders
    sql: SELECT * FROM orders
    source: ${ref(warehouse)}
    metrics:
      - name: revenue
        expression: SUM(amount)
    dimensions:
      - name: order_month
        expression: DATE_TRUNC('month', ordered_at)
  - name: customers
    sql: SELECT * FROM customers
    source: ${ref(warehouse)}

relations:
  - name: orders_to_customers
    join_type: left
    condition: ${ref(orders).customer_id} = ${ref(customers).id}

insights:
  - name: revenue-by-segment
    props:
      type: bar
      x: ?{ ${ref(customers).segment} }
      y: ?{ ${ref(orders).revenue} }

Metrics can also live at the project level and combine metrics from several models. The practical result is fewer wide, pre-joined tables to maintain, and one place to look when someone asks how two models relate. The Metric reference covers the syntax, and relations as a data model explains the reasoning.

Draft, then commit

The second thing to compare is how a change reaches production.

Rill's cloud editing is in beta. Each edit session gets its own git branch and a separate dev deployment, and publishing merges the branch into your primary branch. Locally, you edit files in Rill Developer and push. That is a solid model, and it is fair to say Rill has taken review seriously too.

In Visivo, every edit is a draft first, no matter who or what made it: a person in the visual builder, an engineer in YAML, or the AI agent. You see the list of pending changes, preview them, then commit or discard. In Visivo Cloud, a branch maps to a git branch in your linked repository, so commits push to that branch and merging the default branch deploys it. The same draft boundary applies to the agent, which cannot commit, deploy, or delete on its own.

The difference is mostly one of emphasis. In Visivo, drafts are the normal path for every writer, and the visual builder and the YAML are the same project, so an analyst's drag-and-drop edit and an engineer's pull request go through the same review.

AI: both have it

Rill has real AI features. It ships agent skills that teach Claude Code how to build Rill projects (rill init --agent writes them into your project), an MCP server, and agentic analytics in Rill Cloud with token quotas per seat.

Visivo's agent works inside the project. It reads existing objects, validates a proposed change against the schema, and writes it as a draft for a person to review. Local visivo serve exposes an MCP server at /api/mcp/, so Claude Code or another MCP client can use the same project tools. Locally you can bring your own model key; in Visivo Cloud, agent conversations draw on credit.

Choose on the semantic layer and the workflow. Both tools take AI seriously.

Price: per seat vs one flat number

Here is where the models diverge. Rill's Starter plan is $20 per seat per month, up to 20 seats and 3 projects. Growth is $30 per seat per month, up to 100 seats and 10 projects. Rill also bills compute and storage when Rill manages your data (Starter lists $0.15 per compute-unit hour and $0.10 per GB-month), and every plan includes a $250 usage credit. Rill's pricing page does not say whether view-only users count as seats, so ask them before you budget.

Visivo Platform is $500 a month for the workspace, or $5,000 a year billed annually, however many people you invite. On Visivo, the AI agent and scheduled builds draw on a credit balance that Platform discounts by 20%. Reading dashboards, exploring, and inviting people cost nothing.

Seat fees alone, before either vendor's usage charges:

The honest reading: below about 20 people, Rill is cheaper. A team of ten on Starter pays $200 a month in seats. Visivo also has a free tier, so a solo builder can start without paying anything.

Above 20 people, every Rill option costs more in seats than Visivo Platform, and the gap grows with each person you add. On Growth, Rill passes $500 at 17 seats. The bigger cost of per-seat pricing is the one that never shows up on an invoice: teams start rationing access, and the person who needed the number gets a screenshot instead. A flat price removes that decision. Share the dashboard with the whole company and the bill does not change. See the Visivo pricing page for every tier.

Who should pick Rill anyway

Rill is the better choice if:

• Your workload is high-volume event data and sub-second slice-and-dice on an OLAP engine is the core need.
• Your team is small and will stay small. Up to 20 seats on Starter costs less than Visivo Platform.
• You need embedded analytics today. Rill sells it on Growth. Visivo's embedding is still in beta.
• You already have Rill metrics views that work well. Moving means rebuilding them as a Visivo project.

Who should pick Visivo

Visivo is the better choice if:

• You want joins in the semantic layer, declared once as relations, instead of pre-joined tables for each metrics view.
• You want every edit, human or agent, to go through drafts and review in one project that both the visual builder and the YAML edit.
• You share dashboards widely. Past about 20 people, a flat $500 a month with unlimited members beats per-seat pricing, and nobody has to ration access.
• You build on dbt™ and your existing warehouse. Visivo connects to ten source types, including Snowflake, BigQuery, Postgres, Redshift, ClickHouse, and DuckDB, and layers on your dbt™ models. See sources and dbt™.

Try Visivo

Install the CLI and build your first dashboard locally:

curl -fsSL https://visivo.sh | bash
visivo init
visivo serve

Or start free in Visivo Cloud: no card, $30 of credit to begin, and Platform at $500 a month when your team is ready. The pricing page has every tier, and the product overview walks through each capability.