SCA-C01 Tableau Server Certified Associate Exam Questions and Answers

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.

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.

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 under Site > Settings > General . Server admins can override site admin settings.

Option B (Limitation on storage space) : Correct.

Details : Server admins can set a storage quota per 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 its language (e.g., English, French) and locale (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.

Tableau Server’s performance and stability depend on dedicated resources and proper configuration. Running additional software on the same server is the most likely to cause problems because:

Resource contention : Tableau Server requires significant CPU, RAM, and disk I/O. Other software (e.g., databases, web servers) can compete for these resources, leading to slowdowns, crashes, or failed tasks.

Port conflicts : Tableau uses specific ports (e.g., 80, 443, 8850), and other applications might interfere.

Security risks : Additional software increases the attack surface, potentially compromising Tableau Server.

Tableau recommends running the server on dedicated hardware without unrelated applications.

Option A (Running additional software on the server) : Correct. This is a common cause of performance issues and is explicitly discouraged in Tableau’s best practices.

Option B (Separating the Backgrounder and VizQL processes to different machines) : Incorrect. This is a supported multi-node configuration that can improve performance, not cause problems, if properly set up via TSM.

Option C (Configuring the server to use a static IP address) : Incorrect. A static IP is recommended for Tableau Server to ensure consistent network access, so it’s unlikely to cause issues.

Option D (Using a non-default installation path) : Incorrect. While not default, a custom path is supported (via TSM or installer options) and unlikely to cause problems if permissions and disk space are adequate.

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

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.

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.

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.

In Tableau Server, schedules manage tasks like extract refreshes and subscriptions. Each task within a schedule has a priority value (ranging from 1 to 100, where 1 is the highest priority and 100 is the lowest). Tasks with higher priority (lower numbers) are executed before tasks with lower priority (higher numbers) when queued by the Backgrounder process. If the Backgrounder is overloaded or delayed, lower-priority tasks may not complete on time, leading to inconsistent refreshes.

In this scenario:

The 7:00 AM Extract Refresh task is critical for the CEO’s workbook, but the data is only refreshed 70% of the time by 9:00 AM.

The server has a single node, meaning a single Backgrounder process handles all tasks. With five schedules (some overlapping in the early morning), contention or delays could prevent the 7:00 AM task from completing reliably before 9:00 AM.

Option C (Set the priority of this task to 1): Correct. Setting the task priority to 1 ensures it has the highest priority among all queued tasks. This increases the likelihood that the Backgrounder executes it promptly at 7:00 AM, completing the refresh before the CEO accesses the workbook at 9:00 AM. You can adjust task priority in the Tableau Server web interface under Schedules > Tasks > Edit Priority.

Option A (Set the default priority of this schedule to 50): Incorrect. The default priority for schedules is already 50, and this option refers to the schedule’s default, not the specific task. It wouldn’t address the contention issue.

Option B (Set the priority for all other tasks to 50): Incorrect. This keeps all tasks at the default priority (50), leaving the 7:00 AM task without a relative advantage. It doesn’t prioritize the CEO’s task.

Option D (Set the priority of this task to 100): Incorrect. Priority 100 is the lowest, which would deprioritize the task, making the refresh even less reliable.

Tableau Server’s user-based licensing (Creator, Explorer, Viewer) ties licenses to individual users—let’s determine compatible authentication methods:

User-Based Licensing :

Licenses are assigned per user, tracked by username.

Authentication determines how users log in—must integrate with licensing.

Option A (Local authentication) : Correct.

Details : Users are managed in Tableau Server’s internal database—username/password set manually or via import.

Why : Directly ties to user accounts, fully compatible with licensing.

Option C (Trusted authentication) : Correct.

Details : Allows external apps to authenticate users via tickets (e.g., /trusted/ < ticket > ).

Why : Maps to Tableau usernames, integrating with licensing—common for embedded analytics.

Config : Trusted IPs or credentials set in TSM.

Option D (Active Directory) : Correct.

Details : Uses AD for authentication (LDAP or Kerberos)—users sync to Tableau Server.

Why : AD usernames align with licensing—supports SSO and user management.

Config : Enable via tsm authentication active-directory configure.

Option B (Reliance authentication) : Incorrect.

Why : Not a recognized Tableau authentication method—likely a typo (e.g., for "Resilience" or misheard term). No such feature exists.

Why This Matters : Authentication flexibility ensures user-based licensing fits diverse IT environments—critical for adoption.

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.

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) during publishing. 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.