Analytics-Admn-201 Salesforce Certified Tableau Server Administrator Free Practice Exam Questions (2025 Updated)

Tableau Server uses a PostgreSQL database as its repository to store metadata, user information, and permissions. In a high-availability (HA) setup with multiple nodes, there are typically two repository instances: one active and one passive. The "preferred active repository" refers to designating which repository instance should take priority as the active one. This is managed through Tableau Services Manager (TSM).

The correct method to set the preferred active repository is by using the tsm configuration set command. Specifically, you would use a command like:

tsm configuration set -k pgsql.preferred_host -v

This command allows an administrator to specify the preferred host for the active repository, ensuring control over which node takes precedence in an HA environment.

Option B (tabcmd set command) is incorrect because tabcmd is a command-line utility primarily used for administrative tasks like managing users, groups, and content (e.g., publishing workbooks), not for configuring server topology or repository settings.

Option C (TSM browser client's Maintenance page) is incorrect because the Maintenance page in the TSM web interface is used for tasks like backups, restores, and cleanup, but it does not provide an option to set the preferred active repository.

Option D (TSM browser client's Configuration Topology page) is partially relevant since the Topology page displays the current configuration of services across nodes, including the repository. However, it does not allow direct modification of the preferred active repository; this must be done via the tsm command line.

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.

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.

Tableau Server supports multiple authentication methods, including Local Authentication, Active Directory, Kerberos, SAML, and OpenID Connect. OpenID Connect (OIDC) is an identity layer built on OAuth 2.0, commonly used for single sign-on (SSO). In Tableau Server, OIDC is implemented as a variant of SAML (Security Assertion Markup Language) authentication because both are SSO protocols managed through the same configuration workflow.

To use OpenID Connect:

Configure Tableau Server for SAML/SSO.

Provide an OIDC-compatible identity provider (IdP) configuration (e.g., Google, Okta).

Set up the IdP metadata and certificates in TSM.

Option D (SAML): Correct. Tableau Server treats OIDC as a subset of its SAML authentication framework, so you configure it under the SAML settings in TSM.

Option A (Local Authentication): Incorrect. Local Authentication uses Tableau’s internal user database, not an external SSO protocol like OIDC.

Option B (Kerberos): Incorrect. Kerberos is a network authentication protocol for Windows environments, unrelated to OIDC.

Option C (Active Directory): Incorrect. AD uses LDAP or Kerberos, not OIDC, for authentication.

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’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.

In Tableau Server, projects organize content (workbooks, data sources) and use permissions to control access. "Locking permissions" restricts how permissions are managed within a project—let’s explore this exhaustively:

Permission Management Modes:

Managed by Owner: Default mode. Content owners (e.g., workbook publishers) can set permissions on their items, inheriting project defaults as a starting point.

Locked to the Project: Project-level permissions are enforced, and content owners cannot modify them. This ensures consistency across all items in the project.

How to Lock:

In the Tableau Server web UI:

Go to Content > Projects.

Select a project, click Actions > Permissions.

In the Permissions dialog, change Permissions Management from "Customizable" (Managed by Owner) to "Locked."

Set the desired permissions (e.g., Viewer, Editor) for users/groups, which then apply uniformly to all content.

Via REST API: Use the updateProject endpoint with "permissionsLocked": true.

Option B (You can lock permissions to a project by changing Customizable to Locked): Correct.

Details: This is the precise action in the UI—switching from "Customizable" to "Locked" locks permissions at the project level.

Impact: Owners lose the ability to override permissions on individual workbooks/data sources, enforcing governance.

Example: Set "All Users" to Viewer (Locked)—all content in the project is view-only, regardless of owner intent.

Option A (Locking permissions must be enabled on the Server Settings page): Incorrect.

Why: Locking is a per-project setting, not a server-wide toggle. The Server Settings page (via TSM) controls global configs (e.g., authentication), not project permissions.

Option C (Content permissions are locked by default): Incorrect.

Default: New projects are "Managed by Owner" (Customizable), allowing flexibility unless explicitly locked by an admin.

Option D (By setting the appropriate Project permission role): Incorrect.

Confusion: "Project permission role" isn’t a term—permissions are set via rules (e.g., Viewer, Editor), but locking is a separate action (Customizable → Locked).

Why This Matters: Locking permissions ensures uniform access control, critical for regulated environments or large teams where consistency trumps flexibility.

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.

Data-driven alerts in Tableau Server allow users to receive notifications when data in a view meets certain conditions (e.g., a sales metric exceeds a threshold). By default, this feature is disabled for a site unless explicitly enabled by an administrator.

Option C (Change the data-driven alerts setting on the new site's Settings page): This is the correct answer. In the Tableau Server web interface, a site administrator can navigate to the site’s Settings > General page and enable the option "Let users create data-driven alerts." This must be done manually because the default setting for a new site is disabled. Once enabled, users with appropriate permissions (e.g., Viewer, Explorer, or Creator roles) can create alerts on views they have access to.

Option A (Enable data-driven alerts on the TSM Configuration page): This is incorrect because the TSM Configuration page (accessed via the TSM web UI or CLI) manages server-wide settings like ports, authentication, and processes, not site-specific features like data-driven alerts.

Option B (Run the tsm configuration set -k dataAlerts.checkIntervalInMinutes -v 60 command): This is incorrect. The dataAlerts.checkIntervalInMinutes key controls how frequently Tableau Server checks alert conditions (default is 60 minutes), but it does not enable the feature itself. The feature must first be turned on at the site level.

Option D (No action is necessary): This is incorrect because the default setting for data-driven alerts is off for new sites, requiring explicit action to enable it.

Tableau Server relies on several processes to function, each with a specific role. The Repository process (powered by PostgreSQL) serves as the database for metadata, storing critical information such as:

User and group details.

Permissions and site configurations.

Workbook and data source metadata (e.g., schedules, subscriptions).

Option B (Repository): Correct. The Repository is the centralized database that holds all metadata, making it the backbone of Tableau Server’s content management. There are typically two instances in an HA setup (one active, one passive), monitored by the Cluster Controller.

Option A (Data Engine): Incorrect. The Data Engine manages in-memory data processing and extract storage (e.g., .hyper files), not metadata. It’s separate from the Repository.

Option C (Backgrounder): Incorrect. The Backgrounder handles background tasks like extract refreshes and subscriptions, but it doesn’t store metadata—it interacts with the Repository to retrieve task details.

Option D (File Store): Incorrect. The File Store manages physical extract files and workbook assets, not metadata, which is stored in the Repository.

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.

In an HA Tableau Server cluster, the Coordination Service (ZooKeeper ensemble) maintains cluster state—let’s find the best way to check it:

Coordination Service:

Runs on multiple nodes (3 or 5 in HA) to ensure quorum and failover.

Status indicates if it’s running and synced—critical for cluster health.

Option C (Run tsm status -v): Correct.

Details: tsm status --verbose lists all processes across nodes, including Coordination Service (e.g., "Coordination Service: RUNNING").

Why Best: Provides detailed, node-specific status in the CLI—e.g., "Node 1: RUNNING, Node 2: RUNNING."

Use: Run on the initial node; -v ensures full output.

Option A (TSM web client Status page): Incorrect.

Why: The TSM UI (Server > Status) shows process counts (e.g., "Coordination Service: 3 instances"), but not detailed per-node status—less granular than CLI.

Option B (tsm maintenance ziplogs): Incorrect.

Why: Generates log archives for troubleshooting, not a real-time status check.

Option D (Tableau Server Status page): Incorrect.

Why: The Server Status page (Server > Status in the web UI) monitors application processes (e.g., VizQL), not TSM’s Coordination Service.

Why This Matters: Coordination Service health ensures HA stability—tsm status -v is the admin’s go-to for precision.

Tableau Server’s minimum hardware recommendations for a production single-node deployment ensure reliable performance for small to medium workloads. As of the latest documentation:

CPU: 8 cores (2.0 GHz or higher) to handle concurrent users, rendering, and background tasks.

RAM: 32 GB to support in-memory processing (e.g., VizQL, Data Engine) and caching.

Disk Space: 50 GB free for installation, logs, extracts, and temporary files.

Let’s break it down:

Option C (8-Core CPU, 32 GB RAM, 50 GB free disk space): Correct. This matches Tableau’s official minimum for production:

8 cores ensure sufficient parallelism for processes like Backgrounder and VizQL.

32 GB RAM supports multiple users and extract refreshes.

50 GB disk space accommodates growth (initial install is ~1–2 GB, but logs and extracts expand).

Option A (4-Core, 16 GB RAM, 50 GB): Incorrect. Too low for production—4 cores and 16 GB RAM are below the threshold for reliable performance under load.

Option B (2-Core, 8 GB RAM, 15 GB): Incorrect. This is for non-production (e.g., trial) setups, insufficient for production stability.

Option D (4-Core, 64 GB RAM, 50 GB): Incorrect. 4 cores are inadequate, though 64 GB RAM exceeds the minimum (32 GB).

Why This Matters: Under-spec hardware can lead to slow performance, failed refreshes, or crashes in production—adhering to the minimum ensures stability.

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.