NCP-MCA Sample Questions Answers

According to the Self-Service Blueprint and Task configuration settings, the specific parameter that enables and controls the number of retries for a failed task is theRetry Count.

Retry Count:This integer value determines how many times the system will attempt to re-execute the task if it returns a failure status. If this is set to 0 (default in some views), no retries occur. Setting it to a value of 1 or higher enables the retry logic.

Retry Interval (Option A):This setting defines thewait time(in seconds) between the attempts, but without a positiveRetry Count, the interval is irrelevant.

Timeout (Option B):This defines how long the system waits for a single attempt to complete before marking it as failed.

Nutanix Calm and Self-Service automation workflows require validation within the same execution context used by end users. Nutanix documentation specifies the following principles:

1. Playbook validation requires execution in the same user and project context

Playbooks that target resources using aCalmProjectcategory must be tested in the exact context in which they will operate.

The"Execute on behalf of"option allows the administrator to run the Playbookas if a project user initiated it, ensuring validation of:

Project-based scoping

User permissions

Category-based triggers

Playbook logic and automation flow

This matches the documented requirement that Playbooks must be validated under theintended user execution model, makingOption B correct.

2. Deployment must occur inside the Project to activate category-driven Playbooks

Blueprint deployments only trigger Playbooks when:

The deployment occursinside the Project, and

The VM receives metadata (such as CalmProject category) associated with that Project.

Nutanix Calm documentation highlights that Playbooks relying onProject categoriesonly activate when VMs are provisionedfrom that specific Project.

Deploying from the Marketplace does not guarantee that the correct project context or categories will be applied.

Thus, verifying Playbook execution requires deploying the blueprint assigned to the Project, makingOption D correct.

Why the other options are incorrect

❌Option A – “Execute”

This executes Playbooks only in the admin context, not the Project context. It doesnotvalidate permissions, user behavior, or category-based triggers required for Self-Service operation.

❌Option C – Marketplace deployment

Marketplace deployments do not necessarily apply Project-specific categories or metadata, so they cannot reliably test integration with Playbooks bound to a Project.

Nutanix Playbooks (part of Prism Central Automation) support multiple trigger types—Alert, Event, Webhook—and each trigger defines how automation workflows begin. The Nutanix Automation documentation highlights the following key rules:

1. Event Triggers (Correct Answer)

Playbooks using anEventtrigger supportmultiple playbook tasks, including script tasks, VM power operations, Prism actions, and more.

Nutanix documents specify that:

Event-based Playbooks activate when specificPC or cluster eventsoccur.

After an event trigger fires, administrators may definemultiple sequential actionsinside the Playbook.

This allows complex automation chains such as remediation actions, notification flows, or branching logic.

Therefore,Option D is correct, because Event-triggered Playbooks allow multiple actions to be added.

Why the other options are incorrect

❌Option A — Alert Trigger

Alert triggers only allowone alert definition per Playbook trigger.

Nutanix documentation states that an Alert trigger is mapped toa single alert policy, not multiple alerts.

Thus, Option A is incorrect.

❌Option B — Branch Step

ABranchisnot a trigger; it is aflow control elementusedafterthe Playbook has already started.

Branch steps define conditional paths but do not permit the addition of multiple "actions" as a trigger.

Therefore, Option B is incorrect.

❌Option C — Webhook Trigger

Webhook-triggered Playbooks start when external systems send an HTTP POST request.

While the Playbook may contain multiple tasks after triggering, the question specifically refers to addingmultiple scriptable tasks as part of the trigger, which is not possible.

Webhook triggers acceptonly one incoming webhook definition, not multiple script tasks embedded in the trigger.

Thus, Option C is incorrect.

To automate a notification based on a specific change in the environment (such as a VM powering off), the administrator should leverageIntelligent Operations (X-Play)by creating an event-driven Playbook.

Event Trigger:The "VM Power Off" or "Power State Change" is a system-generatedEvent. X-Play allows administrators to select this specific event as aTrigger. This ensures the automation runs in real-time immediately when the state change occurs, rather than waiting for a schedule (as in Option A).

Action (Slack):X-Play includes a nativeSlackaction (or "Send to Slack"). The administrator configures this action with the Slack Webhook URL and the desired message content.

Why not others?

Option Ais reactive and delayed (polling every 6 hours).

Option Bonly runs once during the initial deployment of the blueprint, not continuously during the VM's lifecycle.

Option Csuggests a Webhook trigger, which requires anexternalsystem to invoke the Playbook. Here, the event originatesinternallywithin Nutanix, so an Event Trigger is the correct choice.

The feature within Nutanix Self-Service (Calm) designed specifically for publishing blueprints to end-users is theMarketplace.

Marketplace:This component acts as an app store for the organization. Administrators and developers create Blueprints and thenpublishthem to the Marketplace.

Process:The "Marketplace and Application Management" capability encompasses the workflow of submitting a blueprint for approval, versioning it, and making it visible to users based on their Project entitlements.

Consumption:Once published, users do not access the raw blueprint design canvas; instead, they access the Marketplace Item to launch (consume) the application.

While "Unified Multi-Cloud Orchestration" describes the platform's broad goal, and "DSL" is a method for creating code-based blueprints, "Marketplace" is the specific functional area for publishing and consumption.

When a Blueprint is designed to trigger external automation (like a Playbook via Webhook or API) or perform post-deployment actions (like applying categories via script), these actions must be explicitly defined asTaskswithin the Blueprint's lifecycle.

The Symptom:The VM provisioning (Substrate) succeeded, but the subsequent logic (Categories/Notifications) failed to happen.

The Cause:In Self-Service, simply creating a Blueprint does not automatically link it to an Intelligent Operations Playbook. The developer must add a specific task (e.g., an HTTP Request task targeting the Playbook trigger, or a specific "Execute Playbook" action) to theService Profile(specifically the Post-Create or Create phase).

If this task is missing, disabled, or misconfigured (e.g., wrong URL or payload), the VM will deploy, but the call to the Playbook will never occur, resulting in missing categories and notifications.

Option A is incorrect because deployment would not start at all without a Project. Option D is incorrect because Playbooks are not published to the Marketplace (Blueprints are).

To automate post-deployment configuration within Nutanix Self-Service (Calm), the administrator must defineTaskswithin the Service lifecycle of the Blueprint.

Service Lifecycle:Every Service (VM) in a blueprint has lifecycle actions, such as Create, Start, Stop, and Delete.

Automation Implementation:The administrator should add specific tasks (e.g., HTTP tasks for API calls to monitoring, Scripts for tagging/email) specifically to theCreateaction (or Package Install phase) of the Service.

Execution:When the blueprint is launched, the Orchestrator provisions the VM (Substrate) and then automatically executes these defined tasks in sequence. This ensures that tagging, monitoring, and notification happen immediately and consistently for every deployment without manual intervention.

Comprehensive and Detailed Explanation

Self-Service platform sync allows Prism Central to periodically collect updates from external providers.

Nutanix documentation states that the providers supportingplatform sync with a 20-minute update windoware:

Nutanix (AHV)

VMware (vSphere)

AWS

These environments support the metadata collection necessary for tracking:

IP changes

Disk resizing

VM availability

Thus, the valid set isNutanix, VMware, and AWS, makingOption Ccorrect.

In Nutanix Self-Service (Calm), applications deployed through Projects can performSnapshot actionson VMs. Snapshot expiration is governed bySnapshot Policies, which define:

Retention period

Number of snapshots to retain

Expiration / deletion schedule

Nutanix documentation specifies thatsnapshot expiration is controlled at the Environment level, which belongs to aProject. When a Snapshot action is executed through Self-Service, Calm references theSnapshot Policy associated with that Environmentto determine how the snapshot will be retained and when it will expire.

Thus, to enforce expiration on snapshots taken from Self-Service:

✔You must create a Snapshot Policy for the Environments in the Project.

Why the other options are incorrect

❌B. MST (Multicloud Snapshot Technology)

MST is used for cross-cloud replication and storage integration—not for setting snapshot expiration policies.

❌C. Approval Policy

Approval Policies govern user-request approval workflows, not snapshot retention.

❌D. Protection Domain

Protection Domains are for DR replication and do not manage snapshot expiration for Calm Self-Service actions.

In the context of Nutanix Self-Service (Calm) Blueprints, anApplication Profileacts as a configuration wrapper that defines a specific variation of the application deployment.1

Combinations:It allows the blueprint developer to define multiple "sizes" or "flavors" of the same application (e.g., "Small," "Medium," "Large") within a single blueprint.

Variables:Each Application Profile maps specific values to the variables defined in the underlying Services and Packages. For example, the "Small" profile might set the vCPU variable to 2 and the Memory variable to 4GB, while the "Large" profile sets them to 8 and 32GB respectively.

User Experience:When a user launches a blueprint from the Marketplace, they select the desired Application Profile, which then determines the specific infrastructure resources (VM specs) and software packages that get deployed.2

When troubleshooting or optimizing blueprints where complex operations (like Provisioning combined with detailed Network Configuration) frequently fail, the recommended best practice is to split the steps into smaller tasks.

In Nutanix Self-Service (Calm), theAudittab provides a sequential log of every task executed during an application's lifecycle. If provisioning and network configuration are bundled into a "single step" (e.g., a large script or a single package install), a failure makes it difficult to determine if the issue was with the VM creation, the OS boot, or the specific network parameter application.

By splitting the logic into distinct tasks (e.g., Task 1: Provision VM, Task 2: Configure Network), the administrator can:

Isolate the failure:The Audit log will clearly show "Provision VM: Success" and "Configure Network: Failed".

Validate inputs:It ensures the VM is fully available before attempting configuration.

Improve Auditing:Granular logs allow for faster root cause analysis of the "misconfigured parameters."

Retrying (Option B) or adding delays (Option D) are reactive measures that do not address the root cause of configuration errors, and disabling logging (Option C) hinders troubleshooting.

Comprehensive and Detailed Explanation

Blueprint tasks in Calm run at specificlifecycle stages:

Pre-create→ Tasks executedbeforeVM creation

Post-create→ Tasks executedafterVM creation butbefore power-on

Pre-delete→ Tasks executed before VM deletion

Post-delete→ Tasks executed after removal

Nutanix documentation states:

Actions that must occurbetween VM provisioning and first power-onshould be added to thePre-createorPost-createstage depending on their dependency.

AD OU assignment requires the VM to exist in inventory butbefore power-on, which aligns with:

✔Pre-create– This is used to configure environment-specific metadata, directory placement, and provisioning adjustmentsprior to initial VM startup.

Correct answer:B

The most efficient and scalable method for managing user access in Nutanix Self-Service Projects is leveraging existing Identity Providers (such as Active Directory).

Add an Active Directory group to a role:When adding users to a Project, the administrator can select an entireDirectory Group(AD Group) and assign a specific Project Role (e.g., Developer, Consumer, Operator) to that group.

Result:All users currently in that AD group, and any users added to that AD group in the future, automatically inherit the assigned Project Role. This eliminates the need to manually manage individual user accounts (Option D) or maintain separate local groups (Option A) within Prism Central.

Comprehensive and Detailed Explanation

When configuring aSelf-Service Account for AWS, Prism Central must be able to:

Resolve AWS service endpoint URLs

Validate API calls via name-based resolution

Nutanix documentation specifies thatDNS is requiredfor all cloud-provider integrations, including AWS, Azure, and GCP.

Therefore,DNSis the required network element.

Correct answer:B

Playbooks in Intelligent Operations (X-Play) areEvent-Driven. They execute strictly when a specific event (trigger) occurswhilethe playbook is active.

The Scenario:The administrator sees the category Expired is present on the VM, and the Playbook is currently enabled.

The Cause (Option B):If the category was applied to the VMwhile the Playbook was disabled(or before it was created), the system generated the "Category Assigned" event, but the Playbook was not listening for it at that time.

Consequence:When the administrator later enables the Playbook, it does not retroactively scan for existing VMs with that category; it only waits fornewassignment events. Since the event was missed, no execution record exists.

To fix this, the administrator would need to re-apply the category (remove and add) while the Playbook is enabled to generate a new event.

In the Nutanix Self-Service (Calm) Blueprint lifecycle, tasks are executed in a specific order relative to the provisioning of the infrastructure (Substrate).

Pre-Create Task:This is the specific phase designed to run scripts or set variablesbeforethe VM provision call is sent to the provider (AHV).

Workflow:

The developer creates a pre-create task (e.g., a Python script) to generate the custom hostname string based on logic (e.g., date, user input, or sequence).

The script outputs this string to a variable (e.g., @@{vm_hostname}@@).

The VM Service configuration (Substrate) references this variable in the "VM Name" or "Hostname" field.

Execution:When the blueprint launches, the pre-create task runs first, populates the variable, and then the VM creation occurs using that calculated name.

Tasks in post-create or package-install (Options B and C) runafterthe VM has already been provisioned and named, making them too late for this requirement.

In Nutanix Prism Central Disaster Recovery, when a Prism Central instance fails over to a recovered site, several automation components—including Playbooks—must be revalidated. Nutanix documentation clearly states:

Playbooks store encrypted credentials locally in the Prism Central database.

When Prism Central is recovered on a DR site, the credential encryption keys donottransfer.

As a result,any credentials previously stored in Playbooks become invalidand must be manually re-entered.

This requirement ensures that the scripts, tasks, remediation sequences, and integrations invoked by the Playbook can authenticate properly after recovery.

Therefore:

Playbookscannot automatically use previously stored credentialsafter a DR failover.

Administrators mustre-enter all credentialsin enabled Playbooks so the automation continues functioning.

Hence, OptionCis correct.

Options A and D are incorrect because Playbooks donotautomatically retain functional credentials after DR recovery.

Option B is incorrect because the presence or absence of a credential provider does not change the need to re-enter credentials.

Playbooks are a feature of Intelligent Operations (formerly Prism Pro or X-Play), not Nutanix Self-Service (formerly Calm). Therefore, the first step is always to access the Intelligent Operations console in Prism Central.

The logical flow for defining an automation routine in a Playbook isTrigger first, then Action.

Select Trigger:The administrator must first definewhenthe playbook runs (e.g., on an Alert, an Event, or Manually).

Add Actions:Once the trigger is established, the administrator defineswhathappens (e.g., Power off VM, Send Email, Slack Notification).

The correct order found in the Nutanix Intelligent Operations Guide is: Access Intelligent Operations > Create Playbook > Select Trigger > Add Actions > Save.

In Nutanix Self-Service (Calm),Endpointsare external execution targets used by Playbooks and Runbooks to run scripts or automation tasks. Nutanix documentation specifies the followingvalid Endpoint types:

Windows Endpoint

Linux Endpoint

Database Endpoints(e.g., PostgreSQL, MySQL)

HTTP/Webhook Endpoints

Calm identifiesWindowsandLinuxmachines as valid, manageable Endpoints, meaning administrators can run scripts, commands, and automation tasks on them.

Why the correct answer is B (Windows)

Windows is explicitly listed as a supported Endpoint type.It supports script execution (PowerShell), credential storage, and remote orchestration through Calm.

Why the other options are incorrect

❌A. API Gateway

An API Gateway isnot an Endpoint typein Self-Service; it is not used for script execution or orchestration.

❌C. CentOS

Although CentOS is a Linux distribution, Calm doesnotregister distribution-specific Endpoints like "CentOS."

Instead, it uses thegeneric Linux Endpoint type, not OS-specific entries.

Therefore, "CentOS" isnota selectable Endpoint type.

❌D. Kubernetes

A Kubernetes cluster can be integrated with Nutanix, but it isnot classified as a Playbook/Runbook Endpointin Self-Service.

Kubernetes resources are handled through Calm Blueprints—not through Endpoint registration for automation tasks.

The placement of applications in Nutanix Self-Service is dictated by the intersection of theProjectconfiguration and theBlueprintdefinition.

Project Construct:The Project defines which infrastructure accounts (Providers) are available for use (e.g., AHV, AWS, Azure). If the Project is configured to allow access tobothAWS and another provider (like on-prem AHV or Azure), the potential exists for deployment to those targets.

Blueprints:The Blueprint (or the specific Environment selected at launch) dictates where the workload actually goes. If the administrator intended "Only AWS," but the Project allows multiple providers and the Blueprints (or the users launching them) are configured to use a non-AWS environment, the application will be deployed there.

Therefore, the cause is that theProject construct(allowing multiple clouds) and theBlueprints(utilizing those available clouds) are configured to allow this distribution. To restrict it, the administrator should remove the unintended providers from the Project's "Infrastructure" or "Environment" settings.

Nutanix Calm documentation states thatApplication Profiles (App Profiles)define:

Default variable values

Deployment targets (cluster, subnet, environment)

Runtime configuration differences across environments

App Profiles act aslogical deployment configurationswithin a blueprint, allowing the same blueprint to be deployed differently across staging, test, or production environments.

Thus, the correct answer isC. App Profiles.

In Nutanix Self-Service (Calm), to share a Runbook across multiple projects, it must be published to the Marketplace.

When an administrator selects an existing Runbook and chooses the "Publish" option:

Secret Handling:The system strictly enforces thatsecrets (passwords/keys) are not published. The administrator is required to verify that no secret values are hardcoded. Any sensitive variables are stripped or must be set to runtime input during the publication process.

Project Selection:During the publication or approval workflow via theMarketplace Manager, the administrator configures theProject Sharingsettings. This determines which projects have access to view and execute the Runbook from the Marketplace.

It is not necessary to clone the Runbook first; the publication process itself creates the Marketplace entry derived from the source Runbook.

Comprehensive and Detailed Explanation

Nutanix Calm naming macros:

@@{calm_random}@@→ Generates a random short string,not guaranteed uniqueacross deployments.

@@{calm_unique}@@→ Generates a unique, monotonically increasing integerguaranteed not to repeat.

Static values (e.g., WNSRV0001) will always collide.

Calm documentation specifies:

calm_uniqueshould be used when a deterministic, guaranteed unique VM name is required across multiple deployments.

Therefore, the correct VM naming pattern is:

✔WNSRV@@{calm_unique}@@

In Nutanix Self-Service (Calm), to protect sensitive data (such as passwords, keys, or personal tokens) from being displayed in plain text in the UI and Audit Logs, the developer must configure them asSecret Variables.

Secret Configuration:When defining a variable in a Blueprint or Runbook, there is a specific checkbox option to mark the variable as "Secret" (often indicated by a lock icon).

Behavior:Once a variable is marked as Secret, the Self-Service engine automaticallymasksthe value (replacing it with asterisks *****) in all Audit Log outputs, task details, and the user interface. It is passed securely to the script execution environment but is never echoed back to the console logs in readable form.

Macros like jsonEncode (Option D) affect formatting, not security masking.

When configuringHTTP Endpointswithin Nutanix Self-Service (to be used by tasks for making API calls), the system provides security controls to ensure trust.

Verify TLS Certificate:This specific checkbox setting in the Endpoint configuration determines whether the Self-Service engine validates the SSL/TLS certificate of the target server.

Security:Checking this box ensures that the connection is secure and that the target identity is verified (preventing Man-in-the-Middle attacks). Unchecking it allows connections to servers with self-signed or invalid certificates (often used in dev/test), but forsecure access, verifying the certificate is the required configuration.

Options A (SSH) and C (Static IP) are unrelated to the security of an outbound HTTP API call. Option B (Proxy) relates to routing, not the security handshake itself.

To ensure that Prism Central sends the appropriate notifications (Alerts/Events) to ServiceNow—allowing ServiceNow's Event Management to process them viaEvent Rules—the administrator must configure an X-Play Playbook that exports these alerts.

According to the Prism Central Intelligent Operations Guide (ServiceNow Integration):

Export of alertsfrom Prism Central is achieved by creating an X-Play playbook.

The administrator should use theAlerts Matching Criteriatrigger. This trigger allows the administrator to define the scope of the export (e.g., "All Critical Alerts" or specific categories).

The Playbook then uses theSend Alert to ServiceNowaction to push these matching alerts to the ServiceNow Event API.

By configuring a Playbook with theAlerts Matching Criteriatrigger, the administrator ensures a continuous, policy-based flow of event data into ServiceNow, satisfying the requirement for Event Rules to have data to process. Option A describes the action but lacks the governing trigger mechanism (matching criteria) that defines "appropriate" events for the integration.

To successfully enable and deploy Nutanix Self-Service (formerly Calm), thePrism Centralinstance must have a configuredFully Qualified Domain Name (FQDN).

Requirement:The Self-Service engine (Calm) runs as a set of containerized microservices. These services rely on internal certificates for secure communication and ingress routing.

Validation:During the enablement of the Self-Service feature, Prism Central validates that an FQDN is configured. If only an IP address is used, the enablement process may fail or the services may not function correctly because the certificate generation process requires a valid hostname to establish trust.

Contrast:While Network Segmentation (A) and SNMP (C) are supported features, they are not mandatory prerequisites for the basic deployment of the Self-Service engine.