Analytics-Admn-201 Salesforce Certified Tableau Server Administrator Questions and Answers

In a high-availability (HA) Tableau Server setup, the Repository (PostgreSQL) has an active and passive instance. Failover occurs if the active Repository fails. Let’s dive into the process:

HA Setup:

Two Repository instances across nodes (active/passive).

Failover switches to the passive instance if the active one becomes unavailable (e.g., crash, network issue).

Cluster Controller:

Role: Monitors all processes (e.g., Repository, File Store) across nodes, detecting failures via heartbeats and status checks.

Failover Decision: If the active Repository stops responding, Cluster Controller initiates failover, promoting the passive instance to active.

Coordination: Works with Coordination Service (ZooKeeper) to update topology but makes the initial detection call.

Option A (Cluster Controller): Correct.

Why: It’s the watchdog process, constantly monitoring Repository health and triggering failover when needed.

Option B (Coordination Service): Incorrect.

Role: ZooKeeper maintains cluster state and coordinates topology updates post-failover, but doesn’t detect the failure—Cluster Controller does.

Option C (Gateway): Incorrect.

Role: Routes client requests—unrelated to internal process monitoring or failover.

Option D (Backgrounder): Incorrect.

Role: Executes background tasks—no involvement in Repository failover decisions.

Why This Matters: Understanding failover ensures HA reliability—Cluster Controller is the linchpin for resilience.

Tableau Server uses a role-based licensing model with three primary license levels: Creator, Explorer, and Viewer. Each license level corresponds to specific site roles that define what users can do on the server.

Viewer License: This is the most restrictive license, allowing users to view and interact with published content (e.g., dashboards and visualizations) but not to create or publish new content.

Site Role: The Viewer license can only be associated with the Viewer site role. This role restricts users to viewing capabilities, aligning with the license’s purpose.

Option A (Creator): Incorrect. The Creator license is for users who can create, edit, and publish content using Tableau Desktop and the web interface. It corresponds to the Creator site role, not Viewer.

Option B (Explorer (can publish)): Incorrect. This is a variation of the Explorer license, which allows users to edit and publish content within limits. It’s more permissive than Viewer.

Option C (Viewer): Correct. The Viewer site role matches the Viewer license level perfectly.

Option D (Explorer): Incorrect. The Explorer license allows users to explore data and create content in the web interface, exceeding the Viewer license’s capabilities.

Table recommendations in Tableau Server suggest popular tables and data sources to users when they create new content in the web authoring environment. This feature is enabled by default but can be disabled at the site level.

Option A (Disable the option using the site Settings page): Correct. A site administrator can disable table recommendations by navigating to the site’s Settings > General page in the Tableau Server web interface and unchecking the option "Enable table recommendations." This prevents users on that site from seeing these suggestions, offering a straightforward UI-based solution.

Option B (Use the command: tsm configuration set -k recommendations.enabled -v false): Incorrect. There is no recommendations.enabled key in the TSM configuration settings. This feature is managed per site, not server-wide via TSM.

Option C (Publish data sources only to projects with permissions locked): Incorrect. Locking permissions restricts access but doesn’t disable the recommendation feature itself. Users with access would still see recommendations.

Option D (Disable the option using the server Settings page): Incorrect. Table recommendations are a site-specific setting, not a server-wide setting. The server Settings page (via TSM) controls global configurations, not this feature.

Abandoned workbooks—those no longer actively used—can clutter Tableau Server and consume resources (e.g., disk space for extracts). Identifying them efficiently requires leveraging built-in administrative tools rather than manual or destructive methods. Let’s explore this in depth:

Tableau Server Admin Views: Tableau provides pre-built administrative views to monitor server health, usage, and content. The Stale Content view, accessible under Server > Status > Administrative Views, is specifically designed to identify content (workbooks, data sources) that hasn’t been viewed or modified recently. It shows:

Content name, owner, and project.

Last viewed date and last modified date.

View count over a period.This view uses Repository data to track usage metrics, making it ideal for spotting abandoned workbooks.

Option A (Use the Stale Content administrative view): Correct. This is the most efficient and non-invasive method. You can filter by last viewed date (e.g., >30 days ago) to identify workbooks with large extracts that users have stopped accessing. From there, you can contact owners or delete the content if policy allows. It’s a server administrator’s go-to tool for content management.

Option B (Examine extract files in ProgramData/.../extract): Incorrect and impractical. The ProgramData/Tableau/Tableau Server/data/tabsvc/dataengine/extract directory stores .hyper extract files, but:

File names are cryptic (e.g., GUIDs), not tied directly to workbook names.

It doesn’t indicate usage or abandonment—only file presence and size.

Manual inspection is time-consuming and error-prone compared to the Stale Content view.

Option C (Delete all extracts and allow them to be re-generated): Incorrect and risky. Deleting extracts (e.g., via tsm maintenance cleanup) removes them without identifying usage. Regeneration only occurs if a schedule or user triggers it, potentially disrupting active users and losing historical data unnecessarily.

Option D (View all workbooks, and sort by the Modified date): Partially effective but inefficient. In the Tableau Server UI (e.g., under Content > Workbooks), you can sort by "Last Modified," but:

It doesn’t show viewership (a workbook might be modified recently but unused).

It’s manual and doesn’t scale for large deployments compared to the Stale Content view.

Why This Matters: The Stale Content view leverages Tableau’s metadata to provide actionable insights, saving time and reducing risk compared to manual or destructive alternatives. It’s part of Tableau’s governance toolkit.

Tableau Server uses caching to speed up workbook loading by storing query results. After a scheduled extract refresh updates the data, the cache may need recomputing—let’s dive into the mechanics:

Caching Basics:

VizQL Cache: Stores rendered views and query results for faster access.

Refresh Trigger: A scheduled refresh updates the underlying extract (.hyper), but the cache isn’t automatically invalidated—it’s demand-driven.

Recompute Conditions: Tableau recomputes the cache when the workbook is accessed (viewed) and its data has changed (e.g., via refresh).

Evaluation:

Option B (The workbook has upcoming scheduled refresh tasks): Correct.

Why: An upcoming refresh task indicates the workbook relies on an extract with a schedule. After the refresh runs, the data changes, priming the cache for recomputation on next view. Without a schedule, no refresh occurs, so this is a prerequisite.

Detail: Schedules are set in Schedules > Tasks—e.g., "Daily at 2 AM."

Option D (The workbook has been viewed recently): Correct.

Why: Viewing triggers cache recomputation if the data has changed (e.g., post-refresh). Tableau uses a "lazy caching" model—cache updates only when a user loads the workbook, ensuring fresh results.

Detail: "Recently" isn’t strictly defined but implies post-refresh access.

Option A (Published in the last month): Incorrect.

Why: Publish date is irrelevant—cache recomputation ties to data changes and access, not publication timing.

Option C (All Users group has permission rule allowing access): Incorrect.

Why: Permissions enable viewing, but recomputation requires actual access (viewing) and a refresh event, not just potential access.

Why This Matters: Caching balances performance and freshness—understanding triggers prevents stale data surprises.

Tableau Server’s licensing ties product keys to specific machines. Moving an environment requires managing activations to stay compliant. Let’s break this down:

Licensing Rules:

A product key can be activated on multiple machines (e.g., Dev, Test, Prod), but only up to the licensed limit (typically 3 for such setups).

Deactivation frees the key for reuse elsewhere.

Recommended Workflow:

Deactivate first: Use tsm licenses deactivate on the old Test machine to release the key.

Then activate: Install on the new hardware and activate with tsm licenses activate -k .

Why: Ensures compliance and avoids activation conflicts (e.g., exceeding the key’s limit).

Option B (Deactivate on Test, then install/activate on new hardware): Correct.

Steps:

On old Test: tsm licenses deactivate.

Install Tableau Server on new hardware.

On new Test: tsm licenses activate -k .

Benefit: Clean, compliant transfer—preserves license integrity.

Option A (Activate new, then deactivate old): Incorrect.

Risk: If the key’s limit is reached (e.g., 3 activations), the new activation fails until deactivation occurs. Order matters.

Option C (Activate new, keep old as backup): Incorrect.

Issue: Exceeds license limit (4 activations) and risks non-compliance. Backup requires deactivation or a separate key.

Option D (Activate new, obliterate old): Incorrect.

Details: tableau-server-obliterate.cmd wipes the entire install (data, config)—overkill and doesn’t formally deactivate the key via TSM, potentially leaving licensing inconsistent.

Why This Matters: Proper license management prevents activation errors and ensures legal use across environments.

To force Tableau Server to require the setup of a new administrator account (e.g., resetting the server to an initial setup state), the tsm reset command is the appropriate tool. This command resets Tableau Server’s administrative configuration, including the TSM administrator account, while preserving content like workbooks and data sources.

Option B (Run the tsm reset command): Correct. Running tsm reset clears the current TSM administrator credentials and configuration settings. The next time you access TSM (e.g., via the web interface or CLI), it prompts you to set up a new administrator account, mimicking the initial setup process. Command: tsm reset --username --password .

Option A (Edit tabsvc.yml): Incorrect. The tabsvc.yml file contains service configuration data, but manually editing it is not supported or recommended for resetting the administrator account. It could also corrupt the installation.

Option C (Run the tsm register command): Incorrect. The tsm register command is used to register Tableau Server with a new product key or identity store, not to reset the administrator account.

Option D (Reinstall Tableau Server): Incorrect. Reinstallation wipes the entire server, including content, and is overkill for this task. The tsm reset command achieves the goal without data loss.

When an extract refresh fails on Tableau Server, troubleshooting requires identifying the root cause—e.g., connectivity issues, resource constraints, or configuration errors. The Backgrounder process handles extract refreshes, so it’s a key focus, but the best diagnostic tool depends on granularity and context. Let’s explore this thoroughly:

Extract Refresh Process:

An extract refresh pulls data from a source (e.g., database, file) into a .hyper file stored on Tableau Server.

The Backgrounder executes these tasks based on schedules or manual triggers.

Errors could stem from: database connectivity, credentials, file access, resource overload, or task misconfiguration.

Option B (Background Tasks for Extracts administrative view): Correct. This is the most direct and detailed method:

Location: In the Tableau Server web UI, go to Server > Status > Background Tasks for Extracts (or site-specific under Site > Status).

Details Provided:

Task name, schedule, and workbook/data source.

Start/end times and status (e.g., Failed, Success).

Error messages (e.g., "Cannot connect to database," "Permission denied").

Why It’s Best: It pinpoints the exact failure (e.g., "timeout," "invalid credentials") for the specific refresh, offering actionable insights without needing to dig through logs manually. Server or site administrators can access this view to diagnose issues quickly.

Example: If the error is "Database login failed," you’d check credentials in the data source settings next.

Option A (Status of the Backgrounder process via tsm status -v): Partially useful but insufficient:

What It Shows: Running/stopped status of all processes (e.g., "Backgrounder: RUNNING").

Limitation: It confirms if Backgrounder is operational but doesn’t reveal why a specific task failed—no error details or task-level granularity.

Use Case: If Backgrounder is stopped or crashed, this might indicate a broader issue, but the question implies a single refresh error, not a server-wide failure.

Option C (The UNC path to the extract’s data source): Relevant but secondary:

Context: If the data source is a file (e.g., CSV on a network share), the UNC path (e.g., \\server\share\file.csv) must be accessible.

Why Not First: The error could be unrelated (e.g., database issue, not file-based). The admin view (B) would reveal if it’s a path issue first, guiding you to check the UNC path only if indicated (e.g., "File not found").

Practical Note: Backgrounder needs share permissions and the Run As account must access it—checking this without context wastes time.

Option D (Whether project permissions are set to Locked): Unlikely cause:

Permissions Impact: Locked permissions restrict who can edit/view content, not whether an extract refresh runs—that’s tied to the data source’s connection settings and Backgrounder execution.

Exception: If the refresh user lacks "Connect" permission to the data source, it might fail, but this is rare (owner/schedule typically has access). The admin view would flag this.

Why This Matters: The Background Tasks view is Tableau’s purpose-built tool for extract diagnostics, saving time and reducing guesswork in production environments.

Tableau Server uses internal secrets (tokens) for secure communication between its processes (e.g., Repository, File Store). These are automatically generated during installation and can be regenerated if compromised or for security maintenance. The command to update these is:

tsm security regenerate-internal-tokens: This regenerates the internal security tokens, ensuring all processes use the new tokens after a restart.

Option C (tsm security regenerate-internal-tokens): Correct. This is the documented command for updating internal secrets.

Option A (tsm data-access caching set -r 1): Incorrect. This command configures caching behavior, not security tokens.

Option B (tsm licenses refresh): Incorrect. This refreshes license data, unrelated to internal secrets.

Option D (tsm security validate-asset-keys): Incorrect. This validates encryption keys for assets, not internal tokens.

When a user reports slow performance for a newly-published workbook on Tableau Server, troubleshooting requires isolating the cause—e.g., data source issues, server load, workbook design, or caching. The first question should establish a baseline to narrow the scope. Let’s analyze this step-by-step with depth:

Performance Context:

A workbook’s speed depends on:

Data Source: Query complexity, size, network latency (e.g., database vs. extract).

Workbook Design: Filters, calculations, dashboard complexity.

Server Resources: VizQL rendering, Backgrounder load, caching.

"Newly-published" implies it’s not yet optimized or cached on the server.

Option A (Does it run any faster in Tableau Desktop?): Correct.

Why First: Comparing Desktop vs. Server performance is the most foundational diagnostic step:

Desktop Baseline: If it’s slow in Desktop (local machine), the issue likely lies in the workbook (e.g., complex queries, large data) or data source (e.g., slow database)—not Server-specific.

Server Difference: If it’s fast in Desktop but slow on Server, the problem could be server-side (e.g., resource contention, network latency to the data source from Server).

Practical Next Steps:

Slow in Desktop: Optimize workbook (e.g., simplify calcs, use extracts).

Fast in Desktop: Check Server (e.g., caching, VizQL load).

Why Critical: Establishes whether the issue is inherent to the workbook/data or introduced by Server—guides all further investigation.

Option B (Does the workbook always run slowly or does performance vary?): Useful but secondary.

Why Not First: Variability (e.g., slow at peak times) points to server load, but without a Desktop baseline, you can’t rule out workbook design. It’s a follow-up question after A.

Detail: Variability might suggest caching or concurrent user impact, but it assumes Server-side causation prematurely.

Option C (How many times have you opened the workbook in Tableau Server?): Less relevant initially.

Why Not First: Frequency of access might affect caching (first load is slower, subsequent loads faster), but it’s too specific and doesn’t isolate Desktop vs. Server. It’s a niche follow-up.

Option D (Did you enable caching on the workbook?): Misleading and incorrect.

Why Not First: Caching is server-managed (e.g., VizQL cache settings via tsm data-access caching set), not a user-toggle per workbook. Users don’t "enable" it—admins do. Plus, it’s premature without a baseline.

Why This Matters: Starting with Desktop performance cuts through assumptions, pinpointing whether the root cause is client-side (workbook/data) or server-side—essential for efficient resolution in production.

Tableau Server’s user-based licensing (Creator, Explorer, Viewer) ties licenses to individual users—let’s determine compatible authentication methods:

User-Based Licensing:

Licenses are assigned per user, tracked by username.

Authentication determines how users log in—must integrate with licensing.

Option A (Local authentication): Correct.

Details: Users are managed in Tableau Server’s internal database—username/password set manually or via import.

Why: Directly ties to user accounts, fully compatible with licensing.

Option C (Trusted authentication): Correct.

Details: Allows external apps to authenticate users via tickets (e.g., /trusted/).

Why: Maps to Tableau usernames, integrating with licensing—common for embedded analytics.

Config: Trusted IPs or credentials set in TSM.

Option D (Active Directory): Correct.

Details: Uses AD for authentication (LDAP or Kerberos)—users sync to Tableau Server.

Why: AD usernames align with licensing—supports SSO and user management.

Config: Enable via tsm authentication active-directory configure.

Option B (Reliance authentication): Incorrect.

Why: Not a recognized Tableau authentication method—likely a typo (e.g., for "Resilience" or misheard term). No such feature exists.

Why This Matters: Authentication flexibility ensures user-based licensing fits diverse IT environments—critical for adoption.

Deleting a user in Tableau Server involves handling their owned content (workbooks, data sources)—let’s analyze the process:

Deletion Rules:

Ownership Check: Tableau prevents deletion if the user owns content to avoid orphaning it.

Action: Instead of deleting, the user’s site role is set to Unlicensed, retaining their account and content ownership.

Resolution: An admin must reassign ownership (e.g., via Users > Actions > Change Owner) before deletion.

Option D (User switched to Unlicensed and NOT deleted): Correct.

Details: Attempting deletion (e.g., Users > Select User > Actions > Delete) triggers a check. If content exists, the user becomes Unlicensed—still in the system but unable to log in.

Why: Protects data integrity—content remains accessible for reassignment.

Option A (Deleted, content to server admin): Incorrect.

Why: No automatic reassignment to the server admin—manual action is required first.

Option B (Deleted, content to project leader): Incorrect.

Why: Project leaders don’t automatically inherit content—no such mechanism exists.

Option C (User and content deleted): Incorrect.

Why: Tableau avoids deleting content with the user—too destructive without explicit intent.

Why This Matters: This safeguard prevents accidental data loss, ensuring admins manage ownership transitions deliberately.

The Backgrounder process in Tableau Server handles tasks like extract refreshes and subscriptions—let’s explore its concurrency:

Backgrounder Behavior:

Each instance is single-threaded for task execution—one task at a time per Backgrounder.

Multiple Backgrounders (e.g., in multi-node setups) increase parallelism, but a single Backgrounder is limited to 1 concurrent task.

Queue: Additional tasks wait in the queue, prioritized by their priority (1–100).

Option A (One): Correct.

Details: A single Backgrounder executes one task (e.g., an extract refresh) until completion before starting the next.

Config: Add more Backgrounders via TSM (tsm topology set-process -n node1 -pr backgrounder -c 2) for more concurrency.

Option B (Two): Incorrect.

Why: Not natively supported—a single Backgrounder doesn’t multi-thread tasks.

Option C (Three): Incorrect.

Why: Exceeds the single-threaded design.

Option D (Unlimited): Incorrect.

Why: Concurrency is fixed at 1 per instance—resources affect queue processing speed, not simultaneous tasks.

Why This Matters: Understanding Backgrounder limits guides scaling—more instances mean more parallel tasks, critical for heavy workloads.