SCA-C01 Tableau Server Certified Associate Exam Free Practice Exam Questions (2025 Updated)

Trusted Ticketsis 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.

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.

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.

Tableau Server consists of multiple processes managed by TSM. When you stop Tableau Server (e.g., via tsm stop), most application processes halt, but some TSM-specific processes remain active to manage the server’s infrastructure. Let’s examine each:

TSM Processes: These include the Administration Controller, Administration Agent, and License Manager, which handle configuration, monitoring, and licensing.

Application Processes: These include VizQL Server, Backgrounder, Data Server, etc., which deliver Tableau’s core functionality and stop when the server is stopped.

When tsm stop is executed:

TheAdministration Controller(port 8850) continues running to manage TSM operations (e.g., restarts, status checks).

TheLicense Managerremains active to validate licenses and ensure compliance, even when the server is offline.

Application processes like VizQL Server and Backgrounder shut down, as they’re tied to user-facing services.

Option B (License Manager): Correct. It persists to handle licensing tasks, ensuring the server can restart without license issues.

Option D (Administration Controller): Correct. It’s the core TSM process, always running to accept commands and manage the server state.

Option A (VizQL Server): Incorrect. VizQL stops, as it renders visualizations for users—an application process tied to active server operation.

Option C (Backgrounder): Incorrect. Backgrounder stops, as it processes background tasks (e.g., extract refreshes), which halt when the server is down.

Why This Matters: Understanding which processes persist helps administrators troubleshoot and manage server lifecycle events effectively.

The tsm maintenance backup command creates a backup file (with a .tsbak extension) that captures critical data needed to restore Tableau Server in case of failure or migration. This backup primarily includes:

Repository data: This encompasses the PostgreSQL database, which stores metadata such as workbooks, data sources, user information, permissions, schedules, and subscriptions.

Configuration data: This includes server settings like authentication methods, port configurations, and service layouts, but it does not include topology data as a separate entity (topology is part of the configuration).

The command does not back up the following:

Extract files (stored in the File Store), which must be backed up separately if needed.

Log files, which are archived using tsm maintenance ziplogs.

Option A (Notification settings) is incorrect because while notification settings are part of the configuration data stored in the repository, they are not the primary focus of the backup. The broader category is "repository data."

Option B (SMTP server settings) is also incorrect for the same reason—SMTP settings are configuration data within the repository, but the backup is not limited to just these settings.

Option D (Topology data) is incorrect because topology data (e.g., how services are distributed across nodes) is part of the configuration included in the backup, but it’s not stored as a standalone item. The .tsbak file is centered on the repository database.

Data-driven alerts notify users when data meets conditions (e.g., sales > $10K). Let’s examine when Tableau checks these:

Alert Mechanics:

Enabled per site (Settings > General > Data-Driven Alerts).

Backgrounder evaluates conditions against extract data.

Check Intervals: Configurable via tsm configuration set -k dataAlerts.checkIntervalInMinutes (default: 60 minutes).

Refresh Trigger: Also checks post-extract refresh for immediate updates.

Option A (Every 60 minutes): Correct.

Details: Default interval—Backgrounder polls every hour to evaluate alert conditions.

Config: Adjustable (e.g., -v 30 for 30 minutes).

Option D (Whenever extracts in the related workbook are refreshed): Correct.

Details: An extract refresh updates the data, triggering an immediate alert check to catch changes promptly.

Why: Ensures timely notifications without waiting for the next poll.

Option B (Every 10 minutes): Incorrect.

Why: Not the default—possible via config, but not standard.

Option C (Whenever a new extract is published): Incorrect.

Why: Publishing creates the extract; alerts trigger on refreshes or polling, not initial publication.

Why This Matters: Timing affects alert responsiveness—balancing frequency and server load is key.

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 toSerial. This is done in the Tableau Server web interface:

Go toSchedules.

Select the schedule, clickActions > Edit Schedule.

UnderExecution, chooseSerialinstead ofParallel.

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.

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

Comments on Tableau Server visualizations facilitate collaboration. Let’s explore what’s supported:

Comments Feature: Enabled per site (Settings > General > Allow Comments). Users with "Add Comment" permission can post on views.

Option B (Text): Correct.

Details: The primary content type—users type free-form text in the comment box.

Use: Notes, questions, or feedback (e.g., "Sales spiked here—why?").

Option C (@mentions): Correct.

Details: Typing @username notifies the mentioned user via email or the UI (if notifications are enabled).

Use: Directs comments to specific people (e.g., "@John, check this trend").

Option A (Interactive snapshots of a view): Incorrect.

Details: Snapshots (static images) aren’t supported in comments—users must take screenshots externally and can’t embed them interactively.

Option D (Images - jpg, png): Incorrect.

Details: No attachment or image embedding in comments—text and mentions only. Workaround: Link to an image hosted elsewhere.

Why This Matters: Comments enhance teamwork, but their simplicity (text + mentions) keeps the interface lightweight and focused.

Registering Tableau Server from the command line involves providing configuration details (e.g., identity store, license) via the tsm register command. Let’s explore this fully:

Registration Process:

Run during initial setup or to update settings (e.g., after changing AD/LDAP config).

Uses a configuration file to pass parameters to TSM.

Command: tsm register --file .

File Format:

Tableau Server usesJSONfor configuration files in TSM commands like tsm register.

Example:

json

CollapseWrapCopy

{

"identityStore": {

"type": "local",

"domain": "example.com"

}

}

JSON is structured, machine-readable, and aligns with Tableau’s modern CLI design.

Option C (JSON): Correct.

Official format for tsm register, per documentation and practical use.

Option A (YML): Incorrect.

While tabsvc.yml exists internally, it’s not for registration—tsm register uses JSON.

Option B (XML): Incorrect.

Older Tableau configs used XML (e.g., workgroup.yml pre-TSM), but TSM standardized on JSON.

Option D (HTTP): Incorrect.

HTTP is a protocol, not a file format—irrelevant here.

Why This Matters: Correct file format ensures seamless registration, avoiding CLI errors in setup or migrations.

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.

TheBackgrounderprocess 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 to1 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.

When Tableau Server uses Active Directory (AD) for authentication, group synchronization imports AD groups and assigns aminimum 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 providesmore accessthan the minimum (e.g., Explorer vs. Viewer), their roleremains unchanged.

If the user’s current role providesless accessthan the minimum (e.g., Unlicensed vs. Viewer), their role isupgradedto 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.

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. Thefirst questionshould 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 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 ofSAML(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.