Tableau Interview Questions 2026: Visualizations, Calculations & Performance

Candidates report that Tableau interviews in 2026 test both technical depth (LOD expressions, table calculations, performance optimization) and business communication (choosing the right chart type, dashboard design principles). Confirm exact product version expectations on the official company careers portal.

Tableau is one of the most widely used BI platforms for self-service analytics. Interview questions span from basic navigation to advanced calculations, data modeling, server administration, and dashboard performance.

---

Data Connections and Sources

Q1. What are the different data connection types in Tableau, and when do you use each?

Tableau has two main connection modes:

Live Connection

• Queries the underlying data source on every interaction.
• Always reflects current data.
• Performance depends on database speed.
• Use when: data changes frequently (operational dashboards), data too large for extract, or security row-level policies must be enforced at the DB level.

Extract (Tableau Data Extract / .hyper)

• Snapshots data into a columnar Hyper file on disk.
• Optimized for fast query performance via in-memory analytics.
• Refreshed on schedule (full or incremental).
• Use when: source is slow, queries are complex, data is mostly static, or users need offline access.

Published Data Sources

• Extracts or live connections published to Tableau Server/Cloud.
• Multiple workbooks share one connection; credentials managed centrally.
• Row-level security applied via user filters or data source filters.

Supported connectors (common interview mentions):

Category	Examples
Files	Excel, CSV, JSON, PDF, Spatial
Databases	MySQL, PostgreSQL, Oracle, SQL Server, Redshift, BigQuery, Snowflake
Cloud	Google Sheets, Salesforce, ServiceNow
ODBC/JDBC	Any ODBC/JDBC compliant source
APIs	Tableau Web Data Connector (WDC) for custom REST APIs

---

Q2. What is a Tableau extract (.hyper file), and how does incremental refresh work?

The Tableau Data Extract is a compressed columnar store optimized for the Hyper query engine (in-memory, vectorized).

Full refresh: Truncates and reloads all data from the source. Scheduled nightly for most use cases.

Incremental refresh: Appends only new rows (based on a chosen column -- typically a date or sequential ID). Much faster for large tables.

-- Incremental refresh logic (Tableau UI setup, not SQL you write)
-- "Identify new rows using column: order_date"
-- "Add rows with order_date > [last extract timestamp]"

-- Tableau translates this to roughly:
SELECT * FROM orders WHERE order_date > '2026-06-07 23:00:00'

Limitations of incremental refresh:

• Only appends new rows; does not update or delete existing rows.
• Use full refresh if data can change in past records.
• Incremental column must be monotonically increasing.

Extract filters: Reduce extract size by filtering during extract creation.

-- Filter during extract: only US orders in last 2 years
-- Reduces .hyper file size and load times
Country = "US" AND order_date >= DATE('2024-06-08')

---

Q3. Explain Tableau's data model: relationships, joins, and blends.

Tableau has three ways to combine data:

Relationships (default since Tableau 2020.2)

• Defines how tables relate at the logical layer without specifying join type upfront.
• Tableau generates the appropriate JOIN type at query time based on what fields are used in the view.
• Preserves row count of each table independently (no inadvertent fan-out for many-to-many).
• Use when: tables have different levels of granularity, you want Tableau to handle join type dynamically.

Joins (physical layer)

• Standard SQL-style joins: INNER, LEFT, RIGHT, FULL OUTER, CROSS.
• Flattened into a single table before analysis.
• Joins happen before filtering.
• Risk: row duplication with one-to-many relationships.
• Use when: you need explicit control, custom join expressions, or legacy compatibility.

Data blending

• Combines data from different data sources (e.g., Salesforce + SQL Server) in the view.
• Primary source queries first; secondary source queries and matches on linking field.
• NOT a join -- aggregated separately, linked in view.
• Limitations: only LEFT join semantics, linking dimensions must match exactly, some calculations unavailable in secondary.

-- When to use each:
-- Same database, same granularity -> Relationship
-- Same database, need specific join type or expression -> Physical Join
-- Different databases/sources -> Data Blend
-- Multiple tables with complex relationships -> Relationship model

---

Calculations and Expressions

Q4. What is the difference between row-level, aggregate, and table calculations in Tableau?

Row-level calculations Computed for each row of data before aggregation. Can be used as dimensions or aggregated.

-- Profit ratio per transaction row
[Profit] / [Sales]

-- Date part extraction
YEAR([Order Date])

-- String manipulation
UPPER(LEFT([Customer Name], 10))

Aggregate calculations Computed across rows; result is a single aggregated value.

-- Profit ratio of totals
SUM([Profit]) / SUM([Sales])

-- Running total (note: this is an aggregate, but without table calc)
AVG([Discount])

-- Conditional aggregate
SUM(IF [Category] = "Technology" THEN [Sales] END)

Table calculations Computed on the results of the query (after aggregation), using the structure of the table in the view. Evaluated in Tableau's memory, not at the database.

-- Running total
RUNNING_SUM(SUM([Sales]))

-- Percent of total
SUM([Sales]) / TOTAL(SUM([Sales]))

-- Rank
RANK(SUM([Sales]))

-- Year-over-year growth
(SUM([Sales]) - LOOKUP(SUM([Sales]), -1)) / ABS(LOOKUP(SUM([Sales]), -1))

Performance order: Row-level, then Aggregate (both pushed to DB), then Table calculations (Tableau engine only, slowest).

---

Q5. Explain LOD expressions with FIXED, INCLUDE, and EXCLUDE examples.

LOD (Level of Detail) expressions let you control aggregation independently of the view.

FIXED Computes at exactly the specified dimensions, ignoring view context.

-- Revenue per customer (regardless of what dimensions are in the view)
{ FIXED [Customer ID] : SUM([Sales]) }

-- Use case: Customer acquisition cohort
-- First order date per customer -- fixed to customer level
{ FIXED [Customer ID] : MIN([Order Date]) }

-- Then in view, group customers by their cohort month
DATETRUNC('month', { FIXED [Customer ID] : MIN([Order Date]) })

INCLUDE Adds dimensions to the view level for the calculation.

-- Average daily sales per region (view has only Region)
-- INCLUDE adds [Order Date] just for this calculation
{ INCLUDE [Order Date] : SUM([Sales]) }
-- Result: for each Region, computes SUM(Sales) per day, then averages across days
-- Without INCLUDE, AVG(SUM([Sales])) would just be SUM(Sales) at region level

EXCLUDE Removes dimensions from the view level for the calculation.

-- View has Region and Category. Compute % of Region total per category.
-- EXCLUDE [Category] to get region total
[Sales] / { EXCLUDE [Category] : SUM([Sales]) }

FIXED vs View filters: FIXED ignores view/dimension filters but respects context filters.

-- If you NEED the LOD to respect a view filter, add to Context Filter
-- Filters menu -> right-click filter -> Add to Context

Common LOD interview question -- customer purchase frequency:

-- Count of orders per customer
{ FIXED [Customer ID] : COUNTD([Order ID]) }

-- Then build a histogram: how many customers made exactly 1 order, 2 orders, etc.
-- Pill the LOD calc onto a dimension shelf -> bins -> histogram

---

Q6. How do table calculations work, and what is "addressing and partitioning"?

Table calculations run on the crosstab result after Tableau fetches data. The key concepts are:

Partitioning: The dimensions that define the scope (restart point) of the calculation. Addressing: The dimensions that define the direction the calculation traverses.

-- Example view: Row = Year, Column = Quarter, Mark = SUM(Sales)
-- Table calculation: RUNNING_SUM(SUM([Sales]))

-- "Compute using: Table (across)" settings:
-- Addressing = Quarter (running sum resets each year, runs across quarters)
-- Partitioning = Year

-- "Compute using: Table (down)" settings:
-- Addressing = Year (running sum resets each quarter, runs down years)
-- Partitioning = Quarter

Common table calculations:

RUNNING_SUM(SUM([Sales]))           -- cumulative sum
RUNNING_AVG(SUM([Sales]))           -- cumulative average
WINDOW_SUM(SUM([Sales]), -2, 0)     -- rolling 3-period sum (current + 2 prior)
WINDOW_AVG(SUM([Sales]), -6, 0)     -- 7-period rolling average

-- Rank with ties handling
RANK(SUM([Sales]))                  -- same rank for ties, gaps after
RANK_DENSE(SUM([Sales]))            -- same rank for ties, no gaps
RANK_UNIQUE(SUM([Sales]))           -- unique rank for every row

-- Percent of total
SUM([Sales]) / TOTAL(SUM([Sales]))

-- Index (row number within partition)
INDEX()

-- Offset value (previous row)
LOOKUP(SUM([Sales]), -1)            -- previous row
LOOKUP(SUM([Sales]), FIRST()-1)     -- last row in partition

---

Q7. What are parameters in Tableau, and how are they used?

Parameters are user-controlled variables that can dynamically change calculations, filters, reference lines, or chart types.

Creating a parameter:

• Name: "Top N"
• Data type: Integer
• Allowable values: Range (1 to 50, step 1)
• Current value: 10

Using a parameter in a calculated field:

-- Top N filter
-- Calculated field: "Top N Filter"
RANK(SUM([Sales])) <= [Top N]

-- Use as a filter on this calculation (check "True")

-- Dynamic metric selection
-- Parameter: "Selected Metric" with values: Sales | Profit | Quantity
CASE [Selected Metric]
    WHEN "Sales" THEN SUM([Sales])
    WHEN "Profit" THEN SUM([Profit])
    WHEN "Quantity" THEN SUM([Quantity])
END

-- Dynamic date granularity
-- Parameter: "Date Level" with values: Day | Week | Month | Quarter | Year
DATETRUNC([Date Level], [Order Date])

Parameter actions (Tableau 2019.2+): Parameters can be updated by clicking on a mark -- no dropdown needed.

-- When user clicks a bar, update "Selected Region" parameter to that region's value
-- Dashboard action: Parameter Action -> Source sheet -> Target parameter

---

Dashboard Design

Q8. What are Tableau dashboard actions, and what types are available?

Dashboard actions create interactivity between worksheets in a dashboard.

Filter actions Click a mark in one sheet to filter other sheets.

-- Setup: Source sheet = "Sales Map", Target = "Monthly Trend"
-- Action trigger: Select
-- Run on: Hover / Select / Menu
-- Clearing selection: Show all values / Exclude all values / Leave the filter

Highlight actions Highlight matching marks in other sheets without filtering.

-- Use case: highlight a customer in a scatter plot and simultaneously
-- highlight their orders in a table

URL actions Navigate to a URL with field values embedded.

-- URL template: https://crm.company.com/customer/[Customer ID]
-- Opens CRM record when clicking a customer row

Go to Sheet actions Navigate to another sheet or dashboard.

Parameter actions (2019.2+) Update a parameter value based on a mark selection.

Set actions (2018.3+) Add/remove values from a Set based on mark interactions.

-- Use case: select customers in a scatter plot to add them to a "Focus Set"
-- Use the Set in downstream calculations:
IF [Focus Set] THEN SUM([Sales]) ELSE NULL END

---

Q9. What are Tableau best practices for dashboard performance?

Data layer:

-- 1. Use extracts over live connections when possible
-- 2. Apply extract filters to reduce data volume before extract creation
-- 3. Use incremental refresh for large tables
-- 4. Aggregate data before bringing into Tableau (custom SQL or views)

-- Custom SQL to pre-aggregate (when raw grain isn't needed):
SELECT
    DATE_TRUNC('month', order_date) AS order_month,
    product_category,
    SUM(sales) AS total_sales,
    COUNT(DISTINCT customer_id) AS unique_customers
FROM orders
GROUP BY 1, 2

View layer:

-- Target: fewer than 5,000 marks per view
-- Reduce fields in the view; use filters aggressively
-- Avoid dense scatter plots -- sample or aggregate to reduce mark count

Filter optimization:

-- Filter execution order in Tableau:
-- 1. Extract filters (applied during extract creation)
-- 2. Data source filters (applied to all sheets using the connection)
-- 3. Context filters (compute first, then remaining filters use result)
-- 4. Dimension filters
-- 5. Measure filters
-- 6. Table calculation filters (slowest -- computed after query)

-- Use context filters (right-click -> Add to Context) for high-cardinality
-- filters that significantly reduce data before other filters run

Dashboard layout:

-- Use floating objects sparingly (can cause render delays)
-- Limit worksheets per dashboard: 3-5 is ideal, >10 slows initial load
-- Use dashboard actions to show detail-on-demand rather than always-visible detail
-- Use device-specific layouts for mobile vs desktop

Performance Recording:

-- Help -> Settings and Performance -> Start Performance Recording
-- Interact with the dashboard
-- Help -> Settings and Performance -> Stop Performance Recording
-- Opens a new workbook showing:
--   - Query execution time
--   - Rendering time
--   - Layout computation time
-- Identify: slow queries (optimize SQL/extract), slow renders (reduce marks)

---

Q10. How do you implement row-level security in Tableau?

Row-level security restricts which rows each user sees. Three main approaches:

1. User filters (simple, small user counts)

-- Create a calculated field "User Filter"
[Region] = USERNAME()

-- Or use a mapping table
-- Data source: user_region_mapping (username, allowed_region)
-- Blend or join to fact table
-- Filter: [username] = USERNAME()

2. User functions in calculated fields

-- USERNAME() returns logged-in user's Tableau username
-- USERDOMAIN() returns domain
-- ISMEMBEROF('group_name') returns TRUE if user is in that Tableau group

-- Example: hide confidential rows for non-admins
ISMEMBEROF('Admins') OR [Sensitivity] <> 'Confidential'

-- Use as a data source filter (applies before view filters)

3. Virtual connections + data policies (Tableau Cloud/Server 2022.1+)

-- Centralized row-level security at the data layer
-- Define policy: WHERE region = USERNAME()
-- Apply to any workbook using the virtual connection
-- Users cannot bypass by downloading the extract

Row-level security with extracts:

-- Option A: Create separate extract per user/group (operational overhead)
-- Option B: Use user functions in data source filters
--   Caveat: user functions make extracts user-specific; must materialize per user
-- Option C: Live connection + database-level row security (most secure)
-- Option D: Tableau VizQL Data Service policies (Tableau Cloud 2023+)

---

Advanced Analytics

Q11. How do you create a year-over-year comparison chart in Tableau?

Method 1: Dual-axis with date filter

-- Drag Order Date to Columns (Month/Year granularity)
-- Drag Sales to Rows twice
-- On second SUM(Sales): right-click -> Add table calculation -> Year over Year Growth
-- Synchronize axes, format as percentage

Method 2: LOOKUP table calculation

-- Calculated field: "YoY Growth"
(SUM([Sales]) - LOOKUP(SUM([Sales]), -1)) / ABS(LOOKUP(SUM([Sales]), -1))

-- Addressing: Year (LOOKUP -1 looks at previous year for same month)
-- Table calc must address across Year, partition by Month

Method 3: LOD for more control

-- Current year sales (view filter: 2026)
{ FIXED [Month] : SUM(IF YEAR([Order Date]) = 2026 THEN [Sales] END) }

-- Prior year sales
{ FIXED [Month] : SUM(IF YEAR([Order Date]) = 2025 THEN [Sales] END) }

-- YoY Growth
([Current Year Sales] - [Prior Year Sales]) / [Prior Year Sales]

---

Q12. What are sets in Tableau, and how are they used?

A Set is a custom field that defines a subset of members in a dimension. Members are either IN or OUT.

Static sets:

-- Right-click a dimension -> Create -> Set
-- Manually select members: "Top 5 Customers" set with specific customer names
-- Useful for: focus analysis, comparison groups

Dynamic sets (condition-based):

-- Right-click Customer -> Create Set
-- Condition tab: SUM(Sales) > 50000
-- Top tab: Top 10 by SUM(Sales)
-- Dynamic sets recalculate when data changes

Using sets in calculations:

-- In/Out indicator
IF [Top Customers Set] THEN "Top Customers" ELSE "Others" END

-- Compare top vs others
SUM(IF [Top Customers Set] THEN [Profit] ELSE NULL END)

-- Ratio of top customers to total
SUM(IF [Top Customers Set] THEN [Sales] END) / SUM([Sales])

Combined sets:

-- Create two sets: "2025 Top Customers" and "2026 Top Customers"
-- Combine: Intersection = retained top customers
--          2025 only = churned top customers
--          2026 only = newly promoted top customers
-- Right-click first set -> Create Combined Set

---

Q13. Explain Tableau's analytics pane and built-in statistical features.

The Analytics pane (sidebar) provides drag-and-drop statistical overlays:

Reference lines, bands, distributions:

-- Constant line: drag to view, type fixed value (e.g., quarterly target = 500000)
-- Average line: SUM(Sales) average across dimension
-- Median with quartiles: box plot overlay
-- Standard deviation band: mean +/- 1 or 2 std devs
-- Reference distribution: specify percentiles (25th, 50th, 75th)

Trend lines:

-- Linear trend: y = mx + b (Sales trend over time)
-- Logarithmic, exponential, polynomial, power
-- Tableau shows p-value and R-squared in tooltip
-- Trend lines can be per-color (per series) or aggregate

Forecasting (ETS model):

-- Drag "Forecast" from Analytics pane
-- Tableau uses exponential smoothing (ETS/Holt-Winters)
-- Configure: forecast length, ignore last N periods, prediction intervals
-- Models: Automatic, Custom (choose error/trend/seasonality: none/additive/multiplicative)
-- Access model parameters: Analysis -> Forecast -> Describe Forecast

Cluster analysis:

-- Drag "Cluster" from Analytics pane
-- Groups marks by similarity across measures
-- Tableau uses k-means (you specify k or let it auto-select)
-- Output: cluster assignment per mark, can save as Group

Box plots:

-- Drag measure to view
-- Show Me -> Box-and-Whisker Plot
-- Or: Analytics pane -> Box Plot
-- Shows: Q1, median, Q3, whiskers (1.5 IQR), outliers

---

Tableau Server and Cloud

Q14. What are the key components of Tableau Server architecture?

Core processes:

Process	Role
VizQL Server	Renders views, executes queries, generates images
Application Server	Authentication, session management, web UI
Data Server	Manages published data source connections, caching
Backgrounder	Handles scheduled refreshes, subscriptions, flow runs
Repository	PostgreSQL database -- stores metadata, workbooks, user info
Cache Server	Redis-based query result cache (reduces redundant DB queries)
Gateway	Nginx reverse proxy -- load balances incoming requests
Coordination Service	ZooKeeper -- leader election, distributed state for multi-node

Request flow:

Browser -> Gateway (Nginx) -> Application Server (auth) -> VizQL Server (render)
                                                                 |
                                                     Data Server (cached query)
                                                                 |
                                                         Source DB (live/extract)

Multi-node deployment (performance scaling):

-- Primary node: Repository + Coordination Service + all processes
-- Additional worker nodes: Add VizQL servers (render capacity)
--                           Add Backgrounders (schedule capacity)
-- Load balancing: Gateway distributes VizQL requests across nodes

---

Q15. How do you manage content governance on Tableau Server/Cloud?

Project hierarchy:

-- Top-level projects: by department or data domain
-- Nested projects: by team, sensitivity, or publication stage
-- Example hierarchy:
   Sales/
     Certified/       <- locked, only certified publishers
     Sandbox/         <- open for exploration
   Finance/
     Confidential/    <- restricted view permissions
     Public/

Permissions model:

-- Permissions set at: Site -> Project -> Workbook/Data Source level
-- Inheritance: child objects inherit from project (can override)
-- Permission capabilities: View, Download, Edit, Move, Set Permissions, Delete
-- Best practice: manage at Project level, not individual content

-- Groups > individual user assignments:
   Group "Sales Analysts" -> View + Download on Sales/Certified
   Group "Sales Publishers" -> Publish + Overwrite on Sales/Sandbox

Certification:

-- Content -> right-click workbook -> Quality Warning or Certification
-- Certified badge visible in Tableau Server/Cloud search
-- Certification notes: "Data refreshed daily, validated by Data Team"
-- Helps users identify trustworthy content vs exploratory drafts

Data Catalog (Data Management add-on):

-- Lineage view: trace data from source -> extract -> published DS -> workbook
-- Data quality warnings: flag stale data, deprecated sources
-- Column-level metadata, business descriptions, ownership
-- Search by field name across all published content

---

Q16. How do you schedule and monitor extract refreshes on Tableau Server?

-- Schedule via UI:
-- Tableau Server -> Content -> Data Sources -> select source
-- Refresh -> Schedule -> Choose schedule (every 15min / hourly / daily / weekly)

-- Schedules managed at: Server -> Schedules tab
-- Backgrounder process runs scheduled tasks

-- Monitor via:
-- Server -> Jobs tab: running, queued, failed jobs
-- Notifications: alert on extract failure (Admin -> Settings -> General -> Alerts)

Programmatic scheduling with REST API:

import tableauserverclient as TSC

# Authenticate
tableau_auth = TSC.TableauAuth('username', 'password', 'site_id')
server = TSC.Server('https://tableau.company.com')

with server.auth.sign_in(tableau_auth):
    # Get all data sources
    all_datasources, _ = server.datasources.get()

    # Trigger immediate refresh
    for ds in all_datasources:
        if ds.name == 'Sales Dashboard DS':
            server.datasources.refresh(ds)
            print(f"Triggered refresh for {ds.name}")

    # List schedules
    all_schedules, _ = server.schedules.get()
    for sched in all_schedules:
        print(f"{sched.name}: {sched.execution_type}, {sched.next_run_at}")

Monitoring extract freshness:

# Check last refresh time
with server.auth.sign_in(tableau_auth):
    all_datasources, _ = server.datasources.get()
    for ds in all_datasources:
        if ds.updated_at:
            age_hours = (datetime.now(timezone.utc) - ds.updated_at).seconds / 3600
            if age_hours > 25:  # stale if not refreshed in 25 hours
                print(f"STALE: {ds.name}, last refresh: {ds.updated_at}")

---

Charts and Visualization

Q17. When do you use each chart type in Tableau?

Chart type	Best for	When NOT to use
Bar chart	Comparing categories	>20 categories
Line chart	Trends over time	Non-temporal x-axis
Scatter plot	Correlation, distribution	Categorical axes
Heatmap	Dense cross-tab patterns	Under 10 cells (use bar)
Treemap	Part-to-whole with hierarchy	>50 categories
Pie/Donut	Part-to-whole (under 6 parts)	Many categories, precise comparison
Box-and-whisker	Distribution with outliers	When median alone suffices
Gantt chart	Project timelines	Non-duration data
Bullet chart	KPI vs target	Multiple KPIs on same axis
Waterfall	Contribution to total change	Non-additive components
Funnel	Conversion rates	Non-sequential stages
Map	Geo-spatial distribution	Non-geographic data

Dual-axis charts:

-- Use when: comparing two measures with different scales
-- Setup: drag second measure to row shelf -> right-click -> Dual Axis -> Synchronize Axes
-- Common: bar (actual) + line (target), bar (revenue) + line (growth %)
-- Risk: misleading if axes not synchronized or clearly labeled

---

Q18. How do you create a cohort retention chart in Tableau?

-- Data needed:
-- user_id, first_purchase_date (cohort assignment), order_date, order_amount

-- Step 1: Cohort month (LOD)
{ FIXED [User ID] : MIN(DATETRUNC('month', [Order Date])) }

-- Step 2: Months since first purchase
DATEDIFF('month', [Cohort Month], DATETRUNC('month', [Order Date]))

-- Step 3: Retention rate (% of cohort users active in each month)
-- Build view: Row = Cohort Month, Column = Months Since First Purchase
-- Mark type: Square (for heatmap)
-- Color: COUNTD([User ID]) / {FIXED [Cohort Month] : COUNTD([User ID])}

-- This gives retention matrix:
-- Cohort Jan 2026: Month 0: 100%, Month 1: 65%, Month 2: 48%, ...
-- Cohort Feb 2026: Month 0: 100%, Month 1: 68%, Month 2: 51%, ...

-- Calculated field: Retention Rate
COUNTD([User ID]) / { FIXED [Cohort Month] : COUNTD([User ID]) }

-- Format Color: diverging palette, 0% to 100%
-- Add % of total label on marks

---

Q19. How do you handle NULL values in Tableau calculations?

-- NULL in aggregates:
SUM([Sales])        -- NULLs excluded from SUM (treated as 0 effectively)
COUNT([Sales])      -- counts non-NULL values
COUNTD([Customer])  -- counts distinct non-NULL values

-- NULL in row-level calculations:
[Sales] + NULL      -- returns NULL (NULL propagates in arithmetic)
[Sales] / [Cost]    -- if Cost is NULL, result is NULL

-- ISNULL and ZN:
ISNULL([Sales])             -- returns TRUE if NULL
ZN([Sales])                 -- returns 0 if NULL, else [Sales]
IFNULL([Sales], 0)          -- same as ZN
IFNULL([Region], "Unknown") -- NULL string replacement

-- NULL in filters:
-- Dimension filter dropdown: check "Null" checkbox to include/exclude NULL rows
-- Calculated filter: NOT ISNULL([Customer ID])

-- NULL in date calculations:
DATEDIFF('day', [Start Date], [End Date])  -- returns NULL if either is NULL
IFNULL(DATEDIFF('day', [Start Date], [End Date]), 0)  -- safe version

-- NULL in table calculations:
-- LOOKUP returns NULL for out-of-bounds positions
-- PREVIOUS_VALUE(0) returns 0 for first row instead of NULL
IFNULL(LOOKUP(SUM([Sales]), -1), 0)

---

Real-World Scenarios

Q20. Design a sales KPI dashboard for a regional sales team using Tableau.

Requirements: 50 sales reps across 4 regions, daily updated pipeline data, targets vs actuals, rep-level drill-down, mobile-compatible.

Architecture:

Data source: Salesforce (live connection via Salesforce connector)
Or: Daily extract from CRM DB -> Tableau extract (faster)
Published data source on Tableau Server with row-level security:
  - Region managers see their region only
  - VP Sales sees all regions
  - Reps see own data only

Dashboard sheets:

1. KPI Banner (top row)

-- Total Revenue: SUM([Deal Value]) WHERE Stage = "Closed Won"
-- vs Target: parameter or from targets table (blend)
-- Win Rate: COUNTD(IF [Stage]="Closed Won" THEN [Opportunity ID] END) / COUNTD([Opportunity ID])
-- Pipeline Coverage: SUM([Open Pipeline]) / ([Remaining Target])
-- Days to Close Avg: AVG(DATEDIFF('day', [Created Date], [Close Date]))

2. Revenue Trend (line chart)

-- X: Order Date (monthly)
-- Y: SUM(Deal Value)
-- Color: Region
-- Reference line: Monthly target
-- Table calc: Running total option for cumulative view

3. Regional Map

-- Geography: State/Region field -> Map
-- Color: Win Rate (diverging: red-white-green)
-- Size: Total Pipeline Value
-- Tooltip: Revenue, Win Rate, # Reps, Top Product

4. Rep Leaderboard

-- Bar chart: Rep Name vs SUM(Revenue)
-- Color: % of quota attainment (red < 80%, yellow 80-100%, green > 100%)
-- Sorted descending by revenue
-- Parameter: metric selector (Revenue / Pipeline / Win Rate)

5. Deal Stage Funnel

-- Funnel chart: Stage vs COUNTD(Opportunity ID)
-- Color: Average days in stage (flag stuck deals)

Interactivity:

-- Filter action: Click region on map -> filter leaderboard + trend to that region
-- Parameter action: Click rep name -> set "Selected Rep" parameter
-- URL action: Click opportunity -> open Salesforce record
-- Device layout: Mobile view hides map, shows KPI banner + leaderboard

---

Q21. How do you debug a Tableau workbook that returns unexpected results?

Systematic debugging approach:

1. Verify data source

-- Data -> Data Source (bottom tab) -> check row count
-- Data -> View Data to see actual rows Tableau loaded
-- Compare with: SELECT COUNT(*) FROM source_table

2. Check calculated fields

-- Right-click calc field -> Edit -> look for logic errors
-- Add calc to a new sheet in isolation with only relevant dimensions
-- Use "Show Me" breakdowns to verify granularity

3. Isolate LOD / table calc issues

-- LOD: add the FIXED dimensions to a test sheet row shelf
--   Verify values match expectations at that granularity
-- Table calc: right-click -> Edit Table Calculation -> verify addressing/partitioning
--   Use "Restart every" and "Compute using" settings carefully

4. Check filter order

-- Remove all filters one by one to find which filter causes unexpected exclusion
-- Remember: measure filters apply AFTER aggregation (can't filter individual rows with measure filter)
-- Use dimension filter for row-level exclusion

5. Check data blending

-- Grey broken link icon on a field = blending issue
-- Ensure linking field values match exactly (case, whitespace)
-- View -> Data -> check which is primary vs secondary

6. Performance recording

-- Help -> Settings and Performance -> Start Performance Recording
-- Reproduces the issue while recording
-- Performance workbook shows exact queries sent to DB
-- Compare query output with expected results

---

Q22. How does Tableau handle large datasets (100M+ rows)?

Strategy 1: Extracts with aggregation

-- Extract only the aggregation needed, not row-level
-- Custom SQL in connection:
SELECT DATE_TRUNC('month', order_date) AS month,
       region, product_category,
       SUM(revenue) AS total_revenue,
       COUNT(DISTINCT customer_id) AS unique_customers
FROM orders
GROUP BY 1, 2, 3
-- Extract of 10K rows replaces 100M-row extract

Strategy 2: Partitioned extracts (Tableau 2022.1+)

-- Logical partitioning: each partition stored as separate .hyper file
-- Query only reads relevant partitions
-- Partition by: year, region, product_category
-- Analogous to Hive/Spark partition pruning

Strategy 3: Live connection to columnar DB

-- Snowflake, BigQuery, Redshift, Databricks -- optimized for ad-hoc aggregation
-- Tableau sends optimized SQL; DB uses MPP execution
-- Tableau query caching prevents duplicate queries
-- Use Tableau's query banding to tag queries for DB-level monitoring

Strategy 4: Viz-level optimization

-- Reduce marks < 5,000 (use LOD pre-aggregation in calc)
-- Replace scatter plots with hexbin or density marks
-- Use Reference Lines instead of plotting all individual points

Strategy 5: Materialized views at source

-- Pre-compute expensive aggregations in the database
-- Point Tableau at the materialized view
-- Schedule materialized view refresh to match Tableau extract schedule

---

FAQ

Q: What is the difference between a dimension and a measure in Tableau? Dimensions are categorical/qualitative fields (Region, Category, Customer Name, dates) -- they define the headers/rows/columns in a view. Measures are quantitative fields (Sales, Profit, Quantity) -- they are aggregated (SUM, AVG, COUNT) in a view. Tableau assigns defaults based on field data type, but you can convert: right-click a field in the Data pane -> Convert to Dimension/Measure. Date fields behave as dimensions by default but can be measured (MIN date, MAX date, DATEDIFF).

Q: When should you use a calculated field vs a custom SQL in Tableau? Use calculated fields for: calculations specific to one workbook, business logic built on top of Tableau's aggregation model, LOD expressions, table calculations, and parameter-driven logic. Use custom SQL for: pre-aggregation before Tableau gets the data (performance), complex joins not achievable in the logical model, database-specific functions not available in Tableau's formula language, and filtering at the source to reduce extract size. Candidates report that overuse of custom SQL can limit Tableau's query optimization and break incremental extract refresh.

Q: How does Tableau handle performance with Snowflake or BigQuery? Tableau pushes SQL to Snowflake/BigQuery and leverages their MPP execution engines. Key practices: use live connection or scheduled extracts (not real-time for 100M+ rows), enable Tableau query caching (repeated identical queries hit Tableau's cache), use custom SQL or views to pre-aggregate at the source, minimize cross-database blending (expensive), and enable Tableau Server's background accelerator (pre-renders views as images on schedule). Confirm current Tableau-Snowflake best practices on the official Tableau help portal.

---

Related Topics

• SQL for Data Analysts
• Data Science Interview Questions
• Statistics for Data Science
• Apache Spark Interview Questions
• Machine Learning Interview Questions