Salesforce Salesforce Certified Tableau Server Administrator Analytics-Admn-201 Exam Dumps: Updated Questions & Answers (October 2025)

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.

The VizQL Server process in Tableau Server handles rendering visualizations and processing queries for users viewing dashboards or workbooks. During installation, Tableau Server automatically configures the number of VizQL instances based on the number of processor cores on the machine, following this rule:

Default VizQL instances = 2 per node, unless manually adjusted post-installation.

In multi-node setups, additional instances may be added based on core count, but the question specifies a single server with 16 cores.

The installer does not scale VizQL instances linearly with core count by default (e.g., it doesn’t set 1 instance per 4 cores). Instead:

For a single-node installation, the default is 2 VizQL instances, regardless of core count (assuming the minimum hardware requirements are met: 8 cores, 32 GB RAM).

Administrators can later adjust this using TSM (e.g., tsm topology set-process) based on performance needs, but the question asks for the default configured by the installer.

Option A (4): Incorrect. Four instances might be configured manually for a 16-core server, but it’s not the default.

Option B (6): Incorrect. Six instances exceed the default for a single node.

Option C (10): Incorrect. Ten instances are far beyond the default and would require manual configuration.

Option D (2): Correct. The installer sets 2 VizQL instances by default on a single-node installation.

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.

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.

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.

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.

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 Tableau Server uses Active Directory (AD) for authentication, group synchronization imports AD groups and assigns a minimum site role (e.g., Viewer, Explorer) to users in that group. This ensures users meet a baseline access level. The behavior for existing users during sync is:

If the user’s current site role provides more access than the minimum (e.g., Explorer vs. Viewer), their role remains unchanged.

If the user’s current role provides less access than the minimum (e.g., Unlicensed vs. Viewer), their role is upgraded to the minimum.

This preserves higher privileges while enforcing a floor. “Reduces access” means the minimum role is lower than the current role (e.g., Viewer vs. Explorer), in which case the existing role stays.

Option A (It will change to the minimum site role only if the minimum site role reduces access): Correct. The user’s role changes only if the minimum increases access (e.g., Unlicensed to Viewer); otherwise, it stays higher.

Option B (It will change only if the minimum provides more access): Incorrect wording. This is the inverse of the actual behavior—change occurs when needed to meet the minimum, not to exceed it.

Option C (It will always change): Incorrect. Existing higher roles are preserved.

Option D (It will never change): Incorrect. It changes if the current role is below the minimum.

TSM is Tableau Server’s management layer, accessible via CLI or web UI (port 8850). HTTPS secures this access—let’s identify the responsible process:

TSM Architecture:

Administration Controller: Core TSM process, running on the initial node, handling configuration, UI, and CLI commands.

HTTPS: Enabled by default on port 8850 with a self-signed certificate (configurable to custom certs).

Option B (Administration Controller): Correct.

Details: Hosts the TSM web UI (https:// :8850) and processes CLI requests. It manages the HTTPS listener, serving the interface securely.

Why: It’s the central hub for TSM operations, including secure access.

Option A (License Manager): Incorrect.

Why: Validates licenses, not responsible for HTTPS or UI access.

Option C (Administration Agent): Incorrect.

Why: Runs on additional nodes in multi-node setups to relay commands to the Controller—no direct HTTPS role.

Option D (Coordination Service): Incorrect.

Why: ZooKeeper manages cluster state, not TSM’s web interface or HTTPS.

Why This Matters: Secure TSM access protects server administration—Administration Controller is the linchpin.

In Tableau Server, schedules manage tasks such as extract refreshes and subscriptions. The execution mode of a schedule determines how tasks within that schedule are processed by the Backgrounder process:

Parallel: Tasks run simultaneously (up to the Backgrounder’s capacity), which is the default setting.

Serial: Tasks run one-at-a-time in sequence, ensuring that one task completes before the next begins.

To ensure tasks associated with a particular schedule run one-at-a-time, you must configure the schedule’s execution mode to Serial. This is done in the Tableau Server web interface:

Go to Schedules.

Select the schedule, click Actions > Edit Schedule.

Under Execution, choose Serial instead of Parallel.

Option A (Set Execution to Serial): Correct. This directly addresses the requirement by forcing tasks to execute sequentially.

Option B (Set Default priority to 0): Incorrect. Priority (1–100) determines the order of task execution across all schedules, not whether tasks run one-at-a-time within a single schedule. Also, 0 is not a valid priority value (minimum is 1).

Option C (Set Frequency to Hourly): Incorrect. Frequency (e.g., hourly, daily) controls when the schedule runs, not how tasks within it are executed.

Option D (Set Execution to Parallel): Incorrect. Parallel execution allows tasks to run simultaneously, which contradicts the requirement.