Hoshang Mehta

Posted on Nov 19

The New Analytics Stack: Data Views Tools Agents

#analytics #ai #database

The New Analytics Stack: Data → Views → Tools → Agents

The modern analytics stack has quietly gone through a massive shift. It's no longer about dashboards—in fact, it's barely about interfaces anymore. We're moving into a world where "chatting with your data" becomes the primary way teams get answers.

The Dashboard Era Is Ending

Dashboards were built for a different era:

Static views: Dashboards show what someone decided was important when they built it. They don't adapt to new questions or changing priorities.

Predefined slices: You can only see data the way the dashboard designer structured it. Want to see it differently? Build a new dashboard.

Horizontal summaries: Dashboards show high-level metrics across many dimensions, but they can't go deep. They show you that revenue is up 20%, but not why.

Useful, sure—but fundamentally surface-level and rigid.

I've watched teams build dozens of dashboards, each answering one specific question. Then they build more dashboards to answer follow-up questions. Then they export data to spreadsheets to answer questions the dashboards can't answer. It's a never-ending cycle of dashboard sprawl.

The Shift: Horizontal + Vertical

For the first time, we can go both horizontal and vertical.

Horizontal: Agents can query across systems—CRM, product analytics, revenue, support tickets, activation patterns—all at once. They don't need separate dashboards for each system.

Vertical: Agents can start with a broad question and drill deeper. They can follow threads that dashboards can't predict. They reveal insights that don't fit neatly into a chart or KPI tile.

Example: You ask "What's going on with customer X?" An agent can:

Pull customer data from HubSpot (horizontal: CRM)
Check product usage from Amplitude (horizontal: product analytics)
Review support tickets from Zendesk (horizontal: support)
Analyze revenue from Stripe (horizontal: billing)
Then drill into why usage dropped last week (vertical: deep dive)
Then check if similar customers had the same issue (vertical: pattern analysis)
Then surface what fixed it for those customers (vertical: solution discovery)

A dashboard can't do this. It would require:

4 different dashboards (one per system)
Exporting data to a spreadsheet
Manually joining the data
Analyzing patterns yourself
Drawing conclusions

An agent does it in seconds.

Why Dashboards Fall Short

Dashboards are great for monitoring known metrics. They're terrible for exploration and discovery.

The "What Report Shows This?" Problem

You have a question. You need to find the right dashboard. But which one?

"Is customer churn in the 'Customer Health' dashboard or the 'Revenue' dashboard?"

"Is product activation in the 'Product Analytics' dashboard or the 'Onboarding' dashboard?"

You spend time hunting for the right dashboard instead of getting answers.

The "I Need to See It Differently" Problem

You find a dashboard, but it doesn't show the data the way you need it.

The dashboard shows "monthly active users by region." You need "weekly active users by customer segment." You can't change it—you need to build a new dashboard or export to a spreadsheet.

The "Why Is This Happening?" Problem

Dashboards show what's happening, but not why.

A dashboard shows "revenue is down 15%." Great. Why? The dashboard doesn't tell you. You need to:

Check another dashboard for customer churn
Check another dashboard for deal pipeline
Check another dashboard for product usage
Manually correlate the data
Form a hypothesis
Test it

This takes hours or days. An agent can do it in minutes.

The "I Need Data from Multiple Systems" Problem

Real questions span multiple systems:

"Which customers are at risk of churning?" (needs: product usage + support tickets + revenue)
"What's driving the pipeline slowdown?" (needs: CRM + product usage + marketing data)
"Why did revenue drop?" (needs: revenue + customer data + product usage)

Dashboards are siloed. Each dashboard shows one system. You need to mentally stitch them together.

The New Stack: Data → Views → Tools → Agents

The analytics stack is evolving. Here's the new architecture:

Data Layer

Your raw data sources:

Databases (Postgres, MySQL)
Data warehouses (Snowflake, BigQuery)
SaaS tools (HubSpot, Stripe, Zendesk)
Product analytics (Amplitude, Mixpanel)

This is your foundation. It's where your data lives.

Views Layer

Governed SQL views that define what data can be accessed:

Unified views that join data across systems
Normalized schemas that map different formats to consistent interfaces
Filtered views that exclude sensitive data
Optimized views that pre-aggregate for performance

Views are the abstraction layer. They turn fragmented, inconsistent data into unified, consistent interfaces.

Example: Instead of querying HubSpot's API, Snowflake's schema, and Zendesk's data model separately, you query a unified customer view that joins all three.

Tools Layer

MCP tools that agents can use to query views:

Tools that answer specific questions
Tools that provide context
Tools that surface insights
Tools that recommend actions

Tools are the interface layer. They translate natural language questions into structured queries.

Example: An agent asks "Which customers are at risk?" The tool queries your customer health view and returns at-risk customers with context.

Agents Layer

AI agents that use tools to answer questions:

Agents that monitor metrics and surface insights
Agents that answer ad-hoc questions
Agents that provide context for decisions
Agents that recommend actions

Agents are the intelligence layer. They reason over your data to provide answers.

Example: You ask "What's going on with customer X?" The agent uses multiple tools to pull context from CRM, product analytics, support, and revenue, then synthesizes an answer.

How This Stack Works in Practice

Let me show you how this works for real questions teams ask every day.

Question: "What's the health of our Q1 pipeline?"

Old way (dashboards):

Open "Sales Pipeline" dashboard
See high-level metrics
Export to spreadsheet for deeper analysis
Manually calculate win rates, deal velocity, at-risk deals
Build charts to visualize trends
Write summary

Time: 2-3 hours

New way (agents):

Ask agent: "What's the health of our Q1 pipeline?"
Agent queries pipeline health view (joins CRM + revenue + product data)
Agent analyzes trends, identifies risks, calculates metrics
Agent returns: "Q1 Pipeline: $2.4M (96% of target). Health: Good. 45 deals. Win rate: 32% (above average). At-risk: 3 deals worth $180K (stuck >30 days). Recommendation: Focus on closing at-risk deals."

Time: 10 seconds

Question: "Why did customer X churn?"

Old way (dashboards):

Open "Customer Health" dashboard
Find customer X
See churn indicator
Open "Support Tickets" dashboard
Find customer X's tickets
Open "Product Usage" dashboard
Find customer X's usage
Manually correlate: "Usage dropped, tickets increased, then churned"
Form hypothesis: "Customer churned due to unresolved support issues"

Time: 30-60 minutes

New way (agents):

Ask agent: "Why did customer X churn?"
Agent queries customer churn analysis view (joins customer data + support tickets + product usage + revenue)
Agent analyzes patterns and correlations
Agent returns: "Customer X churned on March 15. Context: Usage dropped 60% in February. 3 open support tickets (unresolved for 45 days). Last login: 20 days before churn. Similar pattern to 12 other churned customers. Likely cause: Unresolved support issues led to disengagement."

Time: 5 seconds

Question: "Which customers should we focus on this week?"

Old way (dashboards):

Open multiple dashboards
Export data from each
Join in spreadsheet
Calculate scores manually
Sort and filter
Create list

Time: 1-2 hours

New way (agents):

Ask agent: "Which customers should we focus on this week?"
Agent queries customer prioritization view (joins usage + revenue + support + engagement)
Agent calculates priority scores
Agent returns: "5 high-priority customers: Customer A (expansion opportunity: usage up 200%, contract renews in 30 days), Customer B (at-risk: usage down 40%, payment delayed), Customer C (new enterprise: onboarding incomplete, needs attention)..."

Time: 5 seconds

The Technical Architecture

Here's how the stack works technically:

Data Layer: Your Sources

Your data lives in:

Databases: Postgres, MySQL for application data
Data Warehouses: Snowflake, BigQuery for analytics data
SaaS Tools: HubSpot (CRM), Stripe (payments), Zendesk (support), Amplitude (product analytics)

Each system has its own schema, API, and data model.

Views Layer: Unified Access

Views create unified interfaces to your data:

Cross-System Views: Join data across systems in a single query

-- Customer 360 View
SELECT 
  h.customer_id,
  h.customer_name,
  h.email,
  s.order_count,
  s.total_revenue,
  z.open_tickets,
  u.active_users,
  u.feature_adoption
FROM hubspot.customers h
LEFT JOIN snowflake.order_summary s ON h.email = s.customer_email
LEFT JOIN zendesk.ticket_summary z ON h.email = z.customer_email
LEFT JOIN product_analytics.users u ON h.email = u.user_email
WHERE h.is_active = true;

Normalized Views: Map different schemas to consistent formats

-- Normalized Customer View
SELECT 
  COALESCE(c.id, u.user_id) as customer_id,
  COALESCE(c.email, u.email_address) as email,
  COALESCE(c.state, u.region) as state
FROM postgres.customers c
FULL OUTER JOIN snowflake.users u ON c.email = u.email_address;

Optimized Views: Pre-aggregate and filter for performance

-- Pipeline Health View (Pre-Aggregated)
SELECT 
  quarter,
  target_revenue,
  pipeline_revenue,
  deal_count,
  win_rate,
  at_risk_deal_count,
  at_risk_revenue
FROM pipeline_health_aggregated
WHERE quarter = 'Q1 2025';

Views give agents unified, consistent access to all your data.

Tools Layer: Query Interfaces

Tools translate questions into queries:

Pipeline Health Tool: get_pipeline_health(quarter: string)

Queries pipeline health view
Returns pipeline metrics and insights
Provides recommendations

Customer Context Tool: get_customer_context(customer_email: string)

Queries customer 360 view
Returns complete customer context
Includes usage, revenue, support, engagement

Revenue Forecast Tool: get_revenue_forecast(quarter: string)

Queries revenue forecast view
Returns forecast with confidence levels
Includes risk factors and scenarios

Tools are the interface between agents and views. They make views queryable.

Agents Layer: Intelligence

Agents use tools to answer questions:

Pipeline Agent: Monitors pipeline health, surfaces insights, recommends actions

Uses pipeline health tool
Analyzes trends and patterns
Identifies risks and opportunities

Customer Agent: Answers customer questions, provides context, identifies risks

Uses customer context tool
Analyzes customer behavior
Surfaces insights and recommendations

Revenue Agent: Forecasts revenue, analyzes trends, identifies drivers

Uses revenue forecast tool
Analyzes historical patterns
Predicts future outcomes

Agents reason over your data to provide answers. They don't just query—they analyze, correlate, and synthesize.

The Value: Why This Stack Works

This stack works because each layer solves a specific problem:

Views Solve the Fragmentation Problem

Your data is fragmented across systems. Views unify it. Agents don't need to understand HubSpot's API or Snowflake's schema—they query unified views.

Tools Solve the Interface Problem

Views are powerful, but they're still SQL. Tools make views queryable with natural language. Agents ask questions, tools translate to queries.

Agents Solve the Intelligence Problem

Tools provide data. Agents provide insights. They analyze patterns, identify correlations, and synthesize answers.

The Shift in How Teams Work

This stack changes how teams work:

From "What Dashboard?" to "Just Ask"

Before: "What dashboard shows customer health?" → Hunt for dashboard → Find it → Realize it doesn't show what you need → Export to spreadsheet → Analyze manually

After: "What's the health of customer X?" → Get answer in seconds

From Static to Dynamic

Before: Dashboards show predefined metrics. New questions require new dashboards.

After: Agents answer any question. New questions get answered immediately.

From Siloed to Unified

Before: Each dashboard shows one system. Questions spanning systems require multiple dashboards and manual correlation.

After: Agents query unified views that span all systems. Questions get answered with complete context.

From Reactive to Proactive

Before: Dashboards show what happened. You need to interpret and act.

After: Agents surface insights proactively. "3 customers at risk, recommend action" instead of "here's a chart, figure it out."

Building the Stack

Here's how to build this stack:

Start with High-Value Views

Build views that answer questions teams ask every day:

Customer health (joins: CRM + product + support + revenue)
Pipeline health (joins: CRM + revenue + product)
Revenue forecasting (joins: pipeline + historical + expansion)

Start with one view. Make it useful. Then expand.

Create Tools That Answer Questions

Build tools that answer specific questions:

"What's the health of customer X?" → Customer health tool
"What's our pipeline looking like?" → Pipeline health tool
"Which customers are at risk?" → At-risk customers tool

Each tool queries a view and returns an answer.

Connect Agents to Tools

Connect agents to your tools:

Pipeline monitoring agent uses pipeline health tool
Customer support agent uses customer context tool
Revenue forecasting agent uses revenue forecast tool

Agents use tools to answer questions.

Iterate Based on Usage

See how agents use your tools:

What questions do people ask?
What answers are most useful?
What context is missing?
What new questions emerge?

Then iterate. Add new views, refine tools, expand context.

The Interface-Less Future

The next decade isn't interface-heavy. It's interface-less.

Before: You interact with interfaces. You click buttons, fill forms, navigate menus.

After: You ask questions. You get answers. No interfaces needed.

Before: You build dashboards. You maintain them. You update them when requirements change.

After: You build views. Agents query them. Views adapt to new questions automatically.

Before: You export data. You analyze in spreadsheets. You build charts. You write summaries.

After: You ask questions. Agents analyze. Agents synthesize. You get answers.

This isn't about replacing dashboards entirely. It's about recognizing that dashboards are one way to interact with data, and agents are another. For exploration, discovery, and ad-hoc questions, agents are better.

The Foundation: Governed Data Access

This stack only works if you have governed data access. Views are the governance layer.

Views define access: Agents can only query through views. They never see raw tables.

Views control scope: You decide exactly what data agents can access. Exclude sensitive data. Limit data retention. Enforce compliance.

Views ensure consistency: Views normalize schemas and values. Agents query consistent interfaces, not fragmented systems.

Views optimize performance: Views can be pre-aggregated and indexed. Agents query fast, optimized views instead of slow, raw tables.

Without governed views, agents would need raw database access, which creates the security, governance, and performance problems we discussed in earlier posts.

Real Examples: The Stack in Action

Let me show you how teams are using this stack:

RevOps: From Weekly Reports to Instant Insights

Before: RevOps team builds weekly pipeline report. Takes 4 hours. Shows high-level metrics. Team reviews on Monday. Questions come up. Team builds ad-hoc reports. Takes another 2 hours. Answers arrive Tuesday.

After: RevOps team asks agent: "What's our pipeline health?" Agent queries pipeline health view (joins CRM + revenue + product). Returns insights in seconds. Team asks follow-up: "Which deals are at risk?" Agent drills deeper. Returns at-risk deals with context. Team acts immediately.

The stack: Data (HubSpot, Snowflake) → Views (pipeline health view) → Tools (pipeline health tool) → Agents (pipeline monitoring agent)

Support: From Context Switching to Instant Context

Before: Support agent opens ticket. Switches to CRM to get customer info. Switches to product analytics to check usage. Switches to billing to check payment status. Switches to support history to see previous tickets. Manually pieces together context. Takes 5-10 minutes per ticket.

After: Support agent opens ticket. Agent automatically queries customer context view (joins CRM + product + billing + support). Returns complete context in seconds. Agent includes: customer segment, recent activity, previous tickets, usage patterns, billing status. Support agent has everything they need immediately.

The stack: Data (HubSpot, Amplitude, Stripe, Zendesk) → Views (customer context view) → Tools (customer context tool) → Agents (support context agent)

Ops: From Dashboard Monitoring to Proactive Alerts

Before: Ops engineer monitors 5 dashboards. Checks each one. Correlates metrics manually. Identifies issues. Investigates. Takes 30-60 minutes to understand an incident.

After: Ops engineer asks agent: "What's the status of payment processing?" Agent queries infrastructure health view (joins logs + metrics + alerts). Returns: "Payment processing is healthy. Success rate: 99.8%. No incidents. Response time: 120ms (normal)." When an incident occurs, agent automatically surfaces context: "High error rate in API. Related: Recent deployment 15 minutes ago. Recommendation: Check rollback."

The stack: Data (logs, metrics, alerts) → Views (infrastructure health view) → Tools (infrastructure status tool) → Agents (incident response agent)

The Evolution: From Dashboards to Agents

This isn't a replacement—it's an evolution.

Dashboards are still useful for:

Monitoring known metrics
Executive summaries
Scheduled reports
Visual exploration

Agents are better for:

Ad-hoc questions
Cross-system analysis
Deep dives
Proactive insights
Exploration and discovery

The future is both. Dashboards for monitoring. Agents for exploration.

Building Your Stack

If you're building this stack, here's where to start:

1. Identify High-Frequency Questions

What questions does your team ask every day?

"What's the health of our pipeline?"
"Which customers are at risk?"
"What's the status of system X?"

These are your starting points.

2. Build Views That Answer Them

Create views that provide the answers:

Pipeline health view (joins CRM + revenue)
Customer health view (joins CRM + product + support)
Infrastructure health view (joins logs + metrics)

Start with one view. Make it useful. Then expand.

3. Create Tools on Views

Build tools that query your views:

Pipeline health tool
Customer health tool
Infrastructure status tool

Tools make views queryable.

4. Connect Agents to Tools

Connect agents to your tools:

Pipeline monitoring agent
Customer support agent
Incident response agent

Agents use tools to answer questions.

5. Iterate Based on Usage

See how agents use your tools. What questions do people ask? What answers are most useful? What context is missing?

Then iterate. Add new views. Refine tools. Expand context.

The Technical Foundation

This stack requires a technical foundation:

Governed Data Access

Views are the governance layer. They define exactly what data agents can access. No raw database access. No security risks. No governance nightmares.

Unified Data Access

Views unify data across systems. Agents query one interface, not multiple APIs or schemas.

Flexible Querying

Tools translate questions into queries. Agents can ask any question, and tools find the answer.

Intelligent Synthesis

Agents reason over data. They don't just query—they analyze, correlate, and synthesize.

Frequently Asked Questions

Do I need to replace all my dashboards?

No. Dashboards are still useful for monitoring known metrics and executive summaries. Agents are better for ad-hoc questions, exploration, and cross-system analysis. Use both.

How do views differ from traditional data views?

Traditional database views are limited to one database. The new stack's views can join data across multiple systems—databases, warehouses, and SaaS tools—in a single query. This unified access is what makes agents powerful.

Can agents replace data analysts?

Agents complement data analysts. Agents answer routine questions instantly, freeing analysts to focus on complex analysis, modeling, and strategic work. Analysts build views and tools; agents use them.

How do I ensure agents get the right data?

Views define exactly what data agents can access. You control the scope—what columns, what rows, what systems. Agents only query through views, so you have complete control.

What if I need real-time data?

Views can query real-time data or cached data. For critical metrics (incident status, payment processing), use real-time queries. For less critical data (historical reports), use cached views. You choose the right approach for each use case.

How do I build views that span multiple systems?

Use a platform that supports cross-database joins. You can join data from HubSpot, Snowflake, Postgres, Zendesk, and more in a single SQL query. The view becomes your unified interface.

Can I use this stack with my existing analytics tools?

Yes. Views can query your existing data sources. Tools can be built on top of existing views. Agents can use tools alongside your existing analytics tools. This stack complements, not replaces, your current setup.

How do I know if my stack is working?

Monitor how agents use your tools. High usage and low error rates indicate the stack is working. Low usage might indicate tools don't answer the right questions. High error rates might indicate views need optimization.

The analytics stack is evolving. It's no longer about dashboards—it's about agents that reason over governed data views.

The next decade isn't interface-heavy. It's interface-less. And it starts with the new stack: Data → Views → Tools → Agents.

A governed foundation, a flexible middle layer, and an intelligent layer on top that finally feels usable.