Salesforce Analytics-Admn-201 Salesforce Certified Tableau Server Administrator Exam Practice Test

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.

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.

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.

Installing Tableau Server on Windows requires an account with sufficient privileges to configure services, write to the file system, and manage registry settings. Let’s analyze this in depth:

Installation Requirements:

The installer creates services (e.g., Tableau Server Gateway), writes to Program Files and ProgramData, and configures TSM.

It needs local administrative privileges on the machine to perform these tasks.

Post-install, a "Run As" account can be set for services (e.g., NT AUTHORITY\NetworkService), but this is separate from the install account.

Option C (An account in the local administrator group): Correct.

Why: The account must be in the local Administrators group to:

Install software (UAC elevation).

Configure services and ports.

Write to protected directories (e.g., C:\Program Files\Tableau).

Examples: A local admin (e.g., Administrator) or a domain user added to the Administrators group (e.g., DOMAIN\AdminUser).

Process: Log in as this account, run the installer, and provide TSM admin credentials during setup.

Option A (A local user account): Incorrect.

A standard local user (not in Administrators) lacks permissions—installation would fail with "Access Denied" errors.

Option B (A domain user account): Incorrect unless clarified.

A domain user without local admin rights can’t install. If it’s in the Administrators group, it qualifies, but C is more specific.

Option D (NT AUTHORITY\NetworkService): Incorrect.

This is a built-in service account for running services (default "Run As" post-install), not for executing the installer—an interactive user account is required.

Why This Matters: Using the right account prevents install failures and ensures secure configuration—critical for production setups.

Editing permissions on a workbook in Tableau Server depends on the user’s role and the project’s permission settings. Since permissions are not locked (i.e., "Managed by Owner"), let’s dissect who can edit them:

Permission Model:

Not Locked: Owners of content (workbooks, data sources) can set permissions, and Project Leaders can override at the project level.

Site Roles: Define maximum capabilities (e.g., Viewer, Explorer, Creator).

Capabilities: "Set Permissions" is explicit—only certain users get it.

Option C (The workbook’s owner): Correct.

Details: The owner (typically the publisher) has full control over their workbook when permissions are Managed by Owner:

How: In the UI, go to Content > Workbooks > Actions > Permissions—owners can edit rules (e.g., grant Editor to a group).

Site Role: Minimum of Explorer (can publish) or Creator to publish, ensuring "Set Permissions" capability.

Why: Ownership inherently includes permission management unless locked.

Option D (Users set to Project Leader for the workbook’s project): Correct.

Details: Project Leaders are assigned via Content > Projects > Actions > Permissions > Set Project Leader:

Power: Can edit permissions for all content in the project, even if not the owner.

Site Role: Requires Site Administrator or Server Administrator (Creator/Explorer variants suffice).

Why: Overrides ownership in Managed by Owner mode—ensures project-level governance.

Option A (Users with project and workbook Viewer role): Incorrect.

Why: Viewer role (site-level) limits users to viewing—lacks "Set Permissions" capability, regardless of project/workbook rules.

Option B (Users with workbook Interactor role): Incorrect.

Why: "Interactor" isn’t a standard role—likely a misnomer for Explorer or Viewer with interaction permissions (e.g., Filter). No permission-editing rights exist here.

Why This Matters: Knowing who can edit permissions prevents access control gaps—crucial for collaborative or regulated environments.

Tableau Server has specific hardware requirements for production environments to ensure stability and performance. The minimum recommended free disk space for a production installation is 50 GB. This accounts for:

The installation itself (approximately 1–2 GB).

Space for log files, temporary files, and extracts managed by the File Store and Data Engine.

Room for backups and operational overhead.

The full minimum hardware recommendations for a single-node production deployment are:

8 CPU cores (2.0 GHz or faster).

32 GB RAM.

50 GB free disk space (on the system drive, typically C: on Windows).

Option A (32 GB): Incorrect. While 32 GB is the minimum RAM requirement, it’s insufficient for disk space in production.

Option B (50 GB): Correct. This matches Tableau’s official recommendation for production environments.

Option C (15 GB): Incorrect. 15 GB is the minimum for a non-production or trial installation, not production.

Option D (64 GB): Incorrect. While 64 GB exceeds the minimum, it’s not the specified requirement—50 GB is sufficient.

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.

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.

Trusted Tickets is an authentication method in Tableau Server for embedding views in external applications (e.g., portals) without requiring users to log in manually. Here’s how it works:

A trusted application (e.g., a web server) authenticates with Tableau Server using a trusted IP or username/password.

Tableau Server issues a temporary ticket (a unique string).

The ticket is embedded in a view URL (e.g., /trusted//views/...), granting access to the view for a short period (configurable, default 5 minutes).

Option A (Access embedded views without being prompted for credentials): Correct. Trusted tickets enable SSO-like behavior for embedded content, bypassing the login prompt if the ticket is valid. This is ideal for seamless integration into external systems.

Option B (Encrypt database connections): Incorrect. Encryption is handled by data source configurations (e.g., SSL), not trusted tickets, which focus on user authentication.

Option C (Save and edit workbooks): Incorrect. Trusted tickets grant view access, not edit permissions—those depend on the user’s site role and permissions.

Option D (Embed database credentials): Incorrect. Trusted tickets authenticate users to Tableau Server, not databases—database credentials are managed separately in the data source.

Why This Matters: Trusted tickets simplify embedding Tableau content securely in custom applications, enhancing user experience.

In Tableau Server, projects are containers for organizing and securing content. They help manage permissions and structure content hierarchically. Let’s define what can be contained:

Workbooks: Visualizations and dashboards published to the Server.

Data Sources: Published connections or extracts reusable across workbooks.

Nested Projects: Sub-projects within a parent project, introduced in later versions (e.g., 2018.2) for deeper organization.

Option B (Workbooks): Correct. Workbooks are the primary content type in projects, containing views and dashboards.

Option C (Nested Projects): Correct. Nested projects allow hierarchical structuring (e.g., a "Sales" project with "Q1" and "Q2" sub-projects), with inherited or custom permissions.

Option D (Data Sources): Correct. Published data sources reside in projects, providing reusable data connections.

Option A (Groups): Incorrect. Groups are collections of users managed at the site or server level, not stored within projects. Projects contain content, not user entities.

Why This Matters: Projects are key to content governance—knowing what they hold helps administrators organize and secure assets effectively.

Tableau Server’s search functionality relies on an indexed catalog of content (workbooks, data sources, etc.) stored in the Repository. If a user can see a workbook in the UI (e.g., under Content > Workbooks) but not find it via search, the search index may be outdated or corrupted. This can happen due to:

Indexing delays after publishing.

Server maintenance or crashes affecting the index.

Option D (Run the tsm maintenance reindex-search command): Correct. This command rebuilds the search index, ensuring all content (including the user’s workbook) is properly cataloged and searchable. Steps:

Stop Tableau Server (tsm stop).

Run tsm maintenance reindex-search.

Start Tableau Server (tsm start).This is a server administrator task and resolves systemic search issues.

Option A (Re-publish the workbook with keywords): Incorrect. Re-publishing might update the index for that workbook, but it doesn’t fix a broader indexing problem. Keywords enhance relevance, not indexing itself.

Option B (Add tags to the workbook): Incorrect. Tags improve searchability but don’t address an index failure. If the workbook isn’t indexed, tags won’t help.

Option C (Log out, and then log back in): Incorrect. This refreshes the user session but doesn’t affect the server-side search index.

Why This Matters: A reliable search index is critical for content discovery in large deployments—reindex-search ensures consistency.

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.

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.

Subscriptions in Tableau Server deliver workbook views to users via email on a schedule. Group subscriptions apply to all group members—let’s unpack this:

Group Subscription Mechanics:

Created via Workbooks > Actions > Subscribe > Select Group.

Delivers content to all users in the group at the time the subscription runs (e.g., daily PDF).

Dynamic: Membership updates (additions/removals) are reflected automatically on the next run.

Option C (The subscription updates automatically to include the new user): Correct.

Details: When you add a user to the group (e.g., via Users > Groups > Add Users), Tableau Server’s subscription process queries the group’s current membership at runtime. The new user receives the subscription on the next scheduled delivery—no manual action needed.

Example: Group "Sales" has a 9 AM subscription. Add a user at 8 AM—they get the email tomorrow at 9 AM.

Option A (Admin receives notice to approve/deny): Incorrect.

Why: No approval workflow exists for group membership changes in subscriptions—it’s automatic.

Option B (Creator must manually edit): Incorrect.

Why: Subscriptions are tied to the group, not a static user list—manual edits aren’t required for membership changes.

Option D (Only members at creation time): Incorrect.

Why: This would be true for individual subscriptions (static list), but group subscriptions are dynamic.

Why This Matters: Dynamic group subscriptions streamline content delivery as teams evolve, reducing admin overhead.

Tableau Server can record performance metrics for workbooks to troubleshoot slow-loading views. This feature must be enabled at the site level (via Settings > General > Allow Performance Recording). Once enabled, you can trigger recording for a specific view by modifying its URL.

The correct syntax is to append :record_performance=yes& to the view URL, immediately after the session ID. For example:

Original URL: http://server/#/site/my-site/views/workbook/view?:iid=1

Modified URL: http://server/#/site/my-site/views/workbook/view?:iid=1:record_performance=yes &

After loading the view with this parameter, a performance recording is generated and accessible via the Performance option in the toolbar.

Option B (Type :record_performance=yes& at the end of the view URL, immediately after the session ID): Correct. This follows Tableau’s documented method for enabling performance recording.

Option A (Click the Performance link in the toolbar): Incorrect. The Performance link appears only after recording is triggered via the URL; it’s not the method to enable it.

Option C (Type :record_performance=yes& immediately before the session ID): Incorrect. The parameter must follow the session ID (e.g., :iid=1) to function correctly.

Option D (Delete the session ID in the URL and reload the view): Incorrect. The session ID is required for the view to load properly; removing it breaks the URL.