I started with the obvious stuff: live hits the DB every time, extract is a snapshot.
Start by framing the core trade-off: Live connections prioritize real-time data and avoid extract storage but push query load to the source, while extracts offer faster performance and reduced source load at the cost of data latency and storage. Then systematically address each dimension—refresh cadence, query pushdown, extract size—and conclude with clear decision criteria based on use case, data volatility, and infrastructure constraints.
Pro tip: Quantify the impact: mention that extracts can reduce query time from minutes to seconds for large datasets, but if the source is a high-concurrency warehouse like Redshift, live connections might be throttled; always align your choice with SLAs and cost budgets.
Briefly outline the key factors: data freshness, performance, source system load, storage, and maintenance overhead. This sets the stage for a structured comparison.
Discuss how live connections provide real-time data but may strain the source, while extracts require scheduled refreshes (e.g., daily, hourly) and introduce latency. Consider the business need for up-to-the-minute data.
Explain that live connections push queries to the source database, leveraging its compute but risking contention; extracts use Tableau's Hyper engine for fast local queries but may not support all database-specific functions.
For 100M+ rows, extracts can be large (GBs to TBs), impacting storage and refresh times. Discuss options like incremental refresh, filtering, or aggregation to manage size.
Conclude with when to choose each: live for real-time, low-latency needs with a robust source; extract for performance-critical dashboards with acceptable data latency. Mention hybrid approaches like using extracts for development and live for production if needed.
AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.
This is the kind of question that sounds manageable until you're actually talking through it live.
Start by outlining Tableau's order of operations as a sequence of filter stages, then explain how each filter type (data source, context, dimension, measure, TOP N, table calc, LOD) fits into that sequence and affects the data available downstream. Use a concrete example to illustrate how filter order changes results, especially for LOD expressions and table calculations.
Pro tip: Emphasize that context filters create a temporary table that affects subsequent filters and LOD calculations, and that FIXED LODs are computed before dimension filters but after context filters—this nuance often trips up even experienced users.
List the sequence: data source filters, context filters, dimension filters, measure filters, TOP N filters, table calculations, and LOD expressions (FIXED, INCLUDE, EXCLUDE). Explain that this order determines which data is available at each stage.
Describe how data source filters reduce data before extraction, context filters create a subset for subsequent filters, dimension filters operate on dimensions, measure filters on aggregated measures, and TOP N filters limit based on rank. Clarify that table calculations and LODs operate after filters.
Explain that FIXED LODs are computed before dimension filters (but after context filters), INCLUDE LODs after dimension filters, and EXCLUDE LODs after dimension filters but before measure filters. This affects how filters interact with LODs.
Walk through a scenario where changing filter order (e.g., using a context filter vs. a dimension filter) changes the result of an LOD or table calculation, demonstrating the practical impact.
Conclude with best practices: use context filters to optimize performance and control LOD behavior, be cautious with measure filters and table calculations, and always validate results when combining filters with LODs.
AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.
Start by framing performance tuning as a systematic process: profile first, then optimize the biggest bottlenecks. Walk through each area (context filters, extract filters, table calculations, data modeling) with concrete examples and trade-offs, emphasizing how you measure impact and decide between denormalization and joins/relationships based on query patterns and data volume.
Pro tip: Always quantify the impact of each optimization (e.g., 'reduced load time from 30s to 5s') and mention that you validate changes with Tableau's Performance Recording to avoid premature optimization.
Use Tableau's Performance Recording and query logs to pinpoint slow operations (e.g., extracts, calculations, filters). Prioritize optimizations that affect the most users or largest data volumes.
Explain that context filters create a temporary table and can improve performance by reducing data before other filters, but they can also slow down if overused. Extract filters reduce data at the source and are best for large datasets or when you need offline access.
Discuss how table calculations are computed after aggregation and can be expensive if they involve complex partitioning or addressing. Recommend minimizing their use, precomputing in the data source when possible, and using them only for dynamic calculations.
Denormalize when you need maximum performance and can accept data redundancy, especially for extracts. Use joins/relationships when you need flexibility, data integrity, or live connections, but be aware of potential performance hits from complex joins.
After each change, re-measure performance and ensure correctness. Document trade-offs and communicate them to stakeholders, especially when balancing speed vs. flexibility.
AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.
SPICE as the QuickSight analog to extracts was easy.
Structure your answer by first mapping each Tableau concept to its QuickSight equivalent, then highlight key differences in behavior and performance. Finally, discuss a real-world pitfall you've encountered or researched, emphasizing its impact and mitigation. This demonstrates both technical depth and practical experience.
Pro tip: Mention that QuickSight's SPICE is an in-memory engine optimized for performance, but unlike Tableau extracts, it has specific refresh limitations and data size constraints. Also, note that QuickSight's row-level security is implemented via datasets and user groups, which can be more complex to set up than Tableau's user filters.
Explain that Tableau's extracts are similar to QuickSight's SPICE, while live connections map to direct query. Highlight that SPICE is an in-memory optimized engine, but has size limits and refresh schedules, whereas direct query hits the underlying database in real-time.
Describe how Tableau's row-level security uses user filters or data source filters, while QuickSight uses dataset-level RLS with rules based on user or group attributes. Note that QuickSight RLS is enforced at query time and can be more centralized.
Discuss that Tableau filters are applied at the worksheet or data source level with context filters, while QuickSight filters are applied at the visual or dataset level. Mention that QuickSight's filter behavior can differ in terms of aggregation and order of operations.
Choose a specific pitfall, such as performance degradation due to SPICE refresh failures or RLS misconfiguration leading to data leakage. Explain why it occurs and how to avoid it, showing awareness of migration challenges.
AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.