SCA-C01 Tableau Server Certified Associate Exam Questions and Answers

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 supports multi-tenancy via sites, each with customizable settings managed by server or site administrators. Let’s analyze what’s configurable per site:

Site Settings: Found in the web UI underSite > Settings > General. Server admins can override site admin settings.

Option B (Limitation on storage space): Correct.

Details: Server admins can set astorage quotaper site (e.g., 100 GB) to cap disk usage for extracts and workbooks.

How: In TSM or site settings (if enabled)—e.g., tsm configuration set -k site.storage.quota -v 100000.

Impact: Prevents one site from monopolizing resources in multi-site deployments.

Option D (Language and locale): Correct.

Details: Each site can set itslanguage(e.g., English, French) andlocale(e.g., date/number formats).

How: Site settings UI—e.g., "Language: French, Locale: France."

Impact: Tailors the user experience per site’s audience.

Option A (Ability to embed credentials): Incorrect.

Details: Embedding credentials (e.g., in data sources) is a server-wide setting (tsm data-access), not per-site. Site admins can’t override it.

Option C (Limitation on number of users): Incorrect.

Details: User limits are tied to licenses (server-wide), not configurable per site. Site admins manage user assignments, not quotas.

Why This Matters: Site-specific settings enable tailored governance and resource allocation in multi-tenant environments.

In Tableau Server, roles and permissions dictate who can perform specific administrative tasks. A "server administrator" has full control over the entire Tableau Server deployment, while site administrators manage specific sites. Some tasks are restricted to server administrators due to their server-wide impact.

Option B (Adding a site): Creating a new site in a multi-site Tableau Server environment is a server-level task that only a server administrator can perform. Sites are logical partitions within the server, and adding a site affects the overall server structure. Site administrators cannot create new sites; they can only manage existing ones.

Option D (Adding users): Adding users to Tableau Server (e.g., via the TSM interface or tabcmd) is a server administrator task when it involves adding users at the server level or assigning them to the default site. While site administrators can add users to their specific site in a multi-site environment, the initial addition of users to the server requires server administrator privileges. The question’s phrasing (“always require”) suggests a server-wide context, making this a correct choice.

Option A (Creating a schedule): This is incorrect because both server administrators and site administrators can create schedules for tasks like extract refreshes or subscriptions within their scope. It’s not exclusive to server administrators.

Option C (Locking project permissions): This is incorrect because locking project permissions can be done by a site administrator or project leader with appropriate permissions. It’s a project-level action, not a server-level task requiring a server administrator.

Backing up Tableau Server ensures recovery from failures or migrations. A full backup includes multiple data types—let’s dissect this comprehensively:

Backup Components:

Repository Data: PostgreSQL database with metadata (users, permissions, workbooks). Backed up via tsm maintenance backup -f .tsbak.

Configuration Data: Server settings (e.g., ports, authentication) also in the .tsbak file.

Server Secrets: Encryption keys, internal tokens, Repository passwords—critical for restoring functionality.

Extracts: .hyper files in File Store (optional, separate backup).

Option A (Server secrets and Repository passwords): Correct.

Details: Includes encryption keys (for extracts), internal tokens (process communication), and Repository credentials. Backed up separately or stored securely (e.g., tsm security export-keys).

Why Critical: Without these, restored data may be inaccessible or services may fail.

Option C (Configuration data): Correct.

Details: Ports, authentication settings, process topology—part of the .tsbak file.

Why Critical: Restores server behavior and connectivity post-recovery.

Option D (Repository data): Correct.

Details: Core metadata database—also in .tsbak.

Why Critical: Without it, all content and user data is lost.

Option B (Topology data): Incorrect.

Details: Topology (process distribution) is part of configuration data in the .tsbak, not a separate entity. It’s not distinctly backed up as “topology data.”

Why This Matters: A complete backup (secrets, config, repository) ensures full restoration—missing any piece risks an unusable server.

In an HA Tableau Server cluster, theCoordination 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 > Statusin 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.

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.

When an extract refresh fails on Tableau Server, troubleshooting requires identifying the root cause—e.g., connectivity issues, resource constraints, or configuration errors. TheBackgrounderprocess 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 toServer > Status > Background Tasks for Extracts(or site-specific underSite > 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 Desktop and Tableau Server have versioning considerations when publishing content, particularly regarding compatibility between older Desktop versions (e.g., 10.5) and newer Server versions (e.g., 2020.1). Let’s break this down step-by-step:

Version Context: Tableau Desktop 10.5 was released in 2017 and used the .tde (Tableau Data Extract) format for extracts. Tableau Server 2020.1, released in 2020, introduced the .hyper extract format (starting with version 10.5, but fully standardized later). When publishing from an older Desktop version to a newer Server version, Tableau ensures backward compatibility but may upgrade certain components.

Publishing Process: With a Creator site role and Publisher permissions, you have the rights to publish workbooks to the specified project. Tableau Server accepts workbooks from older Desktop versions (e.g., 10.5) and upgrades them to the current Server version (2020.1) duringpublishing. This process is seamless for the workbook itself, but extracts require special handling.

Extract Handling: If the workbook contains embedded .tde extracts (stored within the .twb or .twbx file), Tableau Server 2020.1 converts these to .hyper format upon publishing. This conversion is necessary because .hyper replaced .tde as the default extract engine starting in Tableau 10.5 and beyond, offering better performance and scalability. During this process, Tableau Desktop or Server displays a warning to inform the user of the upgrade, as it’s a one-way conversion (you can’t revert to .tde on the Server).

Now, let’s evaluate the options:

Option A (You will successfully publish without any errors or warnings): Incorrect. While the publishing succeeds, a warning about the .tde to .hyper conversion appears if the workbook contains embedded extracts. Without extracts, no warning occurs, but the question’s context implies extracts are likely involved (common in visualizations).

Option B (Error message: unable to publish to a newer version): Incorrect. Tableau supports publishing from older Desktop versions to newer Server versions. There’s no outright error blocking this; compatibility is maintained.

Option C (Warning: embedded .tde extracts will be upgraded to .hyper): Correct. This is the precise warning displayed when a workbook with .tde extracts is published to a Server version that uses .hyper. It ensures the user is aware of the format change, which might affect extract refresh schedules or performance expectations.

Option D (Warning: workbook will be upgraded to a new version): Partially correct but less specific. The workbook is upgraded to 2020.1 compatibility, but the warning focuses on the extract format change (.tde to .hyper), not the workbook version generically. Option C is more accurate.

Why This Matters: The .tde to .hyper shift improves query performance and supports larger datasets, but users need to know about it for planning (e.g., extract refresh schedules might need adjustment). The warning ensures transparency.

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 provides multiple methods to creategroups(collections of users) andprojects(content containers), catering to UI, CLI, and programmatic needs. Let’s dissect each option with depth:

Option B (Tableau Server browser interface): Correct.

Groups: Go toUsers > Groups > Add Group, name it, and optionally sync with Active Directory.

Projects: Go toContent > Projects > New Project, set name, description, and permissions.

Details: The web UI is intuitive, requiring server/site administrator rights. It’s ideal for manual, ad-hoc creation with immediate visibility.

Permissions: For projects, you can set default permissions or lock them here.

Option C (tabcmd): Correct.

Groups: tabcmd creategroup "GroupName" creates a local group. Add users with tabcmd addusers "GroupName" --users "user1,user2".

Projects: tabcmd createproject -n "ProjectName" -d "Description" creates a project.

Details: tabcmd is a command-line tool for batch operations or scripting (e.g., automating group/project setup). It requires a server admin login (tabcmd login).

Limitation: No AD sync via tabcmd—that’s UI or REST API territory.

Option D (REST API): Correct.

Groups: Use the POST /api/api-version/sites/site-id/groups endpoint with a payload (e.g., {"group": {"name": "GroupName"}}). Supports AD import too.

Projects: Use POST /api/api-version/sites/site-id/projects (e.g., {"project": {"name": "ProjectName", "description": "Desc"}}).

Details: The REST API is programmatic, ideal for integration with external systems or bulk automation. Requires authentication via a token and server/site admin rights.

Power: Offers full control, including nested projects and custom permissions.

Option A (tsm customize): Incorrect.

Purpose: tsm customize modifies TSM UI branding (e.g., logos, colors) via commands like tsm customize --logo "path/to/logo.png".

Why Wrong: It’s unrelated to creating groups or projects—it’s for cosmetic server configuration, not content/user management.

Why This Matters: Offering UI, CLI, and API options ensures flexibility—manual for small tasks, automation for scale—critical in enterprise deployments.

In a high-availability (HA) Tableau Server setup, theRepository(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 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.

Single Sign-On (SSO) allows users to authenticate once (e.g., via a corporate identity provider) and access Tableau Server without re-entering credentials. Tableau Server supports several SSO methods:

OpenID Connect (OIDC): An OAuth 2.0-based protocol for SSO, configured via Tableau’s SAML settings with an OIDC-compatible IdP (e.g., Google, Okta).

Kerberos with Active Directory: A ticket-based SSO protocol, widely used in Windows environments with AD integration.

SAML: A flexible SSO standard using XML assertions, supporting various IdPs (e.g., ADFS, PingFederate).

Let’s evaluate:

Option A (OpenID Connect): Correct. OIDC is an SSO method, implemented as a SAML variant in Tableau Server, enabling seamless login.

Option C (Kerberos with Active Directory): Correct. Kerberos provides SSO in AD environments, delegating authentication to the domain controller.

Option D (Security Assertion Markup Language - SAML): Correct. SAML is a core SSO method in Tableau, widely adopted for enterprise integrations.

Option B (Local Authentication): Incorrect. Local Authentication uses Tableau’s internal user database, requiring manual credential entry—no SSO support.

Why This Matters: SSO enhances user experience and security by leveraging existing identity systems, reducing password fatigue.