What You Will Build

By the end of this tutorial, you will have a fully governed, self-updating analytics dashboard powered by Zenlytic's Zoë self-learning AI. Instead of writing YAML or LookML by hand, you will connect your data warehouse, let Zoë discover your schema automatically, and start asking plain English questions that return verifiable answers with citations. The result is a living semantic layer stored in Git that your entire team can query without waiting on data engineering.

Prerequisites

  • A data warehouse (Snowflake, BigQuery, Databricks, or Postgres). We will use Snowflake in examples.
  • A Zenlytic account (the free self-serve trial supports up to 10 users).
  • Basic familiarity with SQL is helpful but not required.
  • A GitHub account (optional, but recommended for full governance).

The Problem with Traditional BI Setup

Every technical founder knows the pattern: you need a dashboard to track revenue, churn, or user growth. You sign up for a tool like Looker Studio, spend a day connecting data sources, and then the real work begins. You manually drag metrics onto a canvas, define calculated fields, and hope your definitions match what the board expects. When someone asks "Why is MRR different from last month?" you have no easy way to trace the logic.

Traditional BI tools like Looker Studio are free and powerful for static reporting. But they require manual dashboard creation, lack built-in conversational AI, and provide little governance for ad hoc queries. For a founder who needs fast, trustworthy insights without hiring a data engineer, this setup tax is painful.

That is exactly where self-learning AI analytics changes the game. Zenlytic's Zoë Self-Learning, launched in May 2026, connects to your warehouse, reads your schema and query history, and builds a governed context layer in minutes. The company claims zero to governed answers in 59 minutes or less, a claim backed by a 4.9 out of 5.0 rating on Gartner Peer Insights and a 100% likelihood to recommend score. For technical founders who want to spend their energy on product building, not data plumbing, this is a sea change.

In this tutorial, we will tear open the hood of Zoë's self-learning architecture, walk through a real integration, and compare it directly with Looker Studio so you can decide which approach fits your stack.

How Zoë's Self-Learning Works Under the Hood

Zoë's magic lies in its ability to ingest your warehouse's raw schema and transform it into a living, version-controlled semantic layer without manual configuration. Let us look at the core mechanics.

Warehouse Connection and Schema Ingestion

When you point Zoë at Snowflake (or BigQuery, Databricks, Postgres), it performs an automatic scan of your schemas. It reads table names, column names, data types, primary keys, and foreign key relationships. It also reads your warehouse's query history to understand which tables and columns are most used, giving it a head start on which metrics matter.

Under the hood, Zoë uses a multi-model AI architecture. For simple questions like "What was total revenue yesterday?" it routes to a fast, efficient model. For complex, multi-table joins or time series analysis, it can invoke more powerful reasoning models, even using Python for advanced calculations like forecasts. The system chooses the best approach for each query automatically.

The Git Governed Context Layer

The key innovation is that Zoë stores its entire understanding of your data in a Git repository. Every table relationship, every calculated metric, every filter definition lives as code. This means you can branch, review in a pull request, and promote changes just like any other software artifact. Here is what that looks like in practice.

# After initial onboarding, Zoë creates files like these in your GitHub repo.
# Example: revenue_by_day.yml (simplified)

version: 2
metrics:
  - name: total_revenue
    label: Total Revenue
    description: Sum of order amount after discounts
    type: sum
    sql: "{{ dim('order_amount') }} - {{ dim('discount') }}"
    filters:
      - field: status
        operator: equals
        value: confirmed
    model: orders

This YAML is automatically generated by Zoë during its "self-learning" phase. You can see that every metric has a clear SQL definition and inline filters. When a user asks a question, Zoë reads this context layer, writes the appropriate SQL, runs it against your warehouse, and returns the result with inline citations. Hover any number in the answer and you see the source table, filters, and metric definition.

Continuous Refinement Through Feedback

Zoë does not stop learning after onboarding. Every time a user asks a question and then corrects the answer, Zoë incorporates that feedback. Over time, the semantic layer becomes more accurate and more aligned with your business logic. Zenlytic's own CEO, Ryan Janssen, described it as "the LLM is now aware of its own data configuration, and has the power to change it under supervision."

This feedback loop is critical. If you get a wrong metric definition, you simply tell Zoë "This definition should include only active users." Zoë updates the context layer, creates a new Git commit, and future queries automatically use the corrected logic.

Step-by-Step Integration: From Warehouse to Governed Answers

Let us walk through a full integration using Snowflake as our data source. You should be able to complete these steps in under an hour.

Step 1: Connect Your Warehouse

Log into your Zenlytic account and navigate to the data connections page. Select Snowflake. Enter your account identifier, warehouse name, database, and schema. Zenlytic also requires read-only access credentials. The recommended approach is to create a dedicated read-only user for Zoë.

-- SQL to create a read-only user for Zoë in Snowflake
CREATE USER zoe_reader WITH PASSWORD = 'your_secure_password';
GRANT APPLICATION ROLE zenlytic_reader TO USER zoe_reader;
GRANT USAGE ON WAREHOUSE your_warehouse TO ROLE zenlytic_reader;
GRANT SELECT ON ALL TABLES IN SCHEMA your_schema TO ROLE zenlytic_reader;

Once connected, Zoë will scan your schema and show you a list of tables. Select the ones relevant to your business (e.g., orders, customers, payments). You can also choose to upload existing semantic files like dbt models or LookML. Zenlytic can import LookML directly, which is a huge time saver if you are migrating from Looker.

Step 2: Let Zoë Build the Context Layer

After connection, Zoë begins its self-learning phase. It reads column names, data types, and query history to propose initial metric definitions. For example, if it sees columns like order_amount, discount, and status, it will automatically create a total_revenue metric once you confirm. You can see the progress in the "Context" tab.

This step typically takes 5 to 15 minutes. At the end, Zoë presents a list of discovered metrics and dimensions. You review them, make corrections, and they are saved to Git.

Step 3: Ask Your First Question

Now the fun begins. Type a plain English question in the chat interface or in Slack (if you have the integration enabled). For example:

"Show me monthly active users for the last 6 months, broken down by customer tier."

Zoë generates the SQL, runs it, and returns a chart with a breakdown. Every number is clickable: hover it to see the source table, the filter applied, and the metric definition. Here is an example of the SQL it might generate (simplified):

SELECT
  DATE_TRUNC('month', activity_date) AS month,
  customer_tier,
  COUNT(DISTINCT user_id) AS active_users
FROM analytics.fact_activity
WHERE activity_date >= DATEADD('month', -6, CURRENT_DATE)
GROUP BY 1, 2
ORDER BY 1, 2;

If the answer looks correct, you can pin it to a dashboard with one click. If not, you provide feedback.

Step 4: Refine and Promote

Suppose the result shows 10,000 active users, but you know the real number is 8,500 because of a filter on test users. Type: "Exclude users with email domain @test.com." Zoë updates the metric definition and creates a Git commit. You can then review the change in a pull request and promote it to production. The entire loop takes seconds.

Over time, you build a library of governed metrics that any team member can ask about. The system learns which questions are common and surfaces emerging definitions for you to promote.

Zoë vs. Looker Studio: A Technical Founder's Comparison

As a technical founder, you likely want tools that deliver maximum insight with minimum ongoing overhead. Let us stack Zoë against Looker Studio.

DimensionLooker StudioZenlytic Zoë
Setup TimeDays to weeks for a polished dashboardUnder an hour (typically 59 minutes)
Query MethodManual drag-and-dropNatural language conversation
GovernanceNo built-in lineage or citationsFull Git-based lineage, hover citations
Ad-Hoc QuestionsMust create new widgetsInstant conversational answers
PricingFreeIndividual $85/mo, Business $229/mo, Enterprise custom
Best ForLow-cost static reporting over Google dataAI-driven, governed analytics over any warehouse

My opinion: If you are a founder who values speed and trust, Zoë wins hands down. Looker Studio is fine for building a one-time marketing report, but it cannot handle the "why" questions that drive business decisions. With Zoë, you get verifiable answers in seconds, and the semantic layer improves with every interaction. The pricing is not trivial at $85 per month for an individual (or $229 for a team), but consider what you save in data engineering time and the ability to make decisions faster.

For teams that already heavily invest in Google Cloud and need rich visual storytelling, Looker Studio still has its place. But for most technical founders I know, the ability to ask "What drove the churn spike last week?" and get an answer with full lineage is worth the monthly fee.

Common Pitfalls and Best Practices When Deploying Zoë

Even a self-learning AI needs a little guidance. Here are the mistakes I see most often and how to avoid them.

Pitfall 1: Neglecting Data Quality Before Onboarding

If your warehouse tables have inconsistent column names, missing primary keys, or junk rows, Zoë's initial semantic layer will inherit those problems. Clean your core tables first. Standardize naming (e.g., always user_id, never id or uid). Define clear primary keys so Zoë can understand relationships.

Pitfall 2: Skipping the Feedback Loop

Zoë is not a set-and-forget tool. If you never correct incorrect definitions, the system learns wrong patterns. Run a pilot with two or three power users. Have them ask real questions and actively correct errors. Each correction improves the model for everyone. Over time, the system becomes remarkably accurate.

Pitfall 3: Expanding Too Quickly

Resist the urge to invite your entire company on day one. If 50 users start asking questions while the semantic layer is still immature, you will get inconsistent answers and people will lose trust. Start with a small group, iterate for a week or two, and only then scale to the full team.

Pitfall 4: Blindly Trusting AI Visualizations

Zoë can generate charts, but AI can sometimes produce visually misleading representations (overly aggressive scaling, wrong chart type). Always pair AI-generated visuals with human review, especially for board presentations. Use Zoë's Clarity Engine to hover numbers and verify the underlying logic.

Implications for the Future of Business Intelligence

What Zoë points to is a future where business intelligence becomes conversational. Instead of building dashboards that answer known questions, teams can ask any question at any time and get a governed answer instantly. This flips the BI model from "build first, ask later" to "ask first, build as needed."

For technical founders, the implication is clear. You no longer need to hire a dedicated data analyst just to get answers from your warehouse. Zoë democratizes analytics for non-technical stakeholders while maintaining enterprise-grade governance through Git. The result is faster decision-making and less time spent on data plumbing.

Of course, this does not eliminate the need for data engineering entirely. Someone still needs to ensure data quality and maintain the warehouse schema. But the bottleneck of manual dashboard creation and semantic layer setup disappears. That is a future worth building for.

Next Steps

Cover photo by Steve A Johnson on Pexels.