Salesforce-MuleSoft-Platform-Architect Exam Questions With Explanations
The best Salesforce-MuleSoft-Platform-Architect practice exam questions with research based explanations of each question will help you Prepare & Pass the exam!
Over 15K Students have given a five star review to SalesforceKing
Why choose our Practice Test
By familiarizing yourself with the Salesforce-MuleSoft-Platform-Architect exam format and question types, you can reduce test-day anxiety and improve your overall performance.
Up-to-date Content
Ensure you're studying with the latest exam objectives and content.
Unlimited Retakes
We offer unlimited retakes, ensuring you'll prepare each questions properly.
Realistic Exam Questions
Experience exam-like questions designed to mirror the actual Salesforce-MuleSoft-Platform-Architect test.
Targeted Learning
Detailed explanations help you understand the reasoning behind correct and incorrect answers.
Increased Confidence
The more you practice, the more confident you will become in your knowledge to pass the exam.
Study whenever you want, from any place in the world.
Start practicing today and take the fast track to becoming Salesforce Salesforce-MuleSoft-Platform-Architect certified.
21524 already prepared
Salesforce 2026 Release 152 Questions 4.9/5.0
An organization requires several APIs to be secured with OAuth 2.0, and PingFederate has been identified as the identity provider for API client authorization, The
PingFederate Client Provider is configured in access management, and the PingFederate OAuth 2.0 Token Enforcement policy is configured for the API instances required by the
organization. The API instances reside in two business groups (Group A and Group B) within the Master Organization (Master Org).
What should be done to allow API consumers to access the API instances?
A. The API administrator should configure the correct client discovery URL in both child business groups, and the API consumer should request access to the API in Ping Identity
B. The API administrator should grant access to the API consumers by creating contracts in the relevant API instances in API Manager
C. The APL consumer should create a client application and request access to the APT in Anypoint Exchange, and the API administrator should approve the request
D. The APT consumer should create a client application and request access to the API in Ping Identity, and the organization's Ping Identity workflow will grant access
C. The APL consumer should create a client application and request access to the APT in Anypoint Exchange, and the API administrator should approve the request
Explanation:
When using PingFederate as an external OAuth 2.0 provider with the PingFederate OAuth 2.0 Token Enforcement policy in Anypoint Platform:
* The policy validates access tokens issued by PingFederate.
* Client registration (creating client_id/secret) and access granting (scope approval for specific APIs) are still managed within Anypoint Platform.
* API consumers discover the API in Anypoint Exchange, create a client application in API Manager, and request access (contract) to the specific API instance(s) in Group A and/or Group B.
* The API administrator (in the relevant business group) approves the contract request in API Manager.
* Upon approval, the consumer obtains their client_id and client_secret from their client application in Anypoint Platform.
* The consumer then registers this client_id/secret with PingFederate (via dynamic client registration or manual config, depending on PingFederate setup) to obtain tokens.
* Tokens issued by PingFederate are validated by the Anypoint policy.
Key point: Even with an external IdP like PingFederate, API access contracts (which APIs/scopes a client can access) are governed in Anypoint API Manager, not in PingFederate or Ping Identity workflows.
Why the other options are incorrect:
A. Incorrect. There is no "client discovery URL" configured per child business group for this scenario, and consumers do not request access directly in Ping Identity.
B. Incorrect. Administrators do not manually create contracts for consumers; consumers request access, and admins approve.
D. Incorrect. Access to the API (not just token issuance) is granted via Anypoint Platform contract approval, not via a Ping Identity workflow.
Reference: MuleSoft documentation on external OAuth 2.0 providers (including PingFederate) confirms that client applications and API contracts are managed in Anypoint Platform, while token issuance/validation uses the external provider. Approval happens in API Manager/Exchange. This is a common scenario in MuleSoft Platform Architect certification.
A company is using an on-prem cluster in the data center as a runtime plane and MuleSoft- hosted control plane.
How can the company monitor the detailed performance metrics on the Mule applications deployed to the cluster from the control plane?
A. The settings of the Monitoring section in the control plane must be updated to enable detailed logging on the metrics to be captured
B. Monitoring Agent must be installed on each node in the cluster
C. Due to the potential performance impact on the runtime nodes, the Monitoring agent should be installed on a separate server
D. There is no action needed as the on-prem runtime automatically sends the performance data to the control plane
B. Monitoring Agent must be installed on each node in the cluster
Explanation:
When using Hybrid deployment (on-premises runtime plane + MuleSoft-hosted control plane), the Mule applications deployed to the on-prem cluster do not automatically send detailed performance metrics to the control plane.
To enable Anypoint Monitoring for these runtimes:
* A Monitoring Agent must be installed on each node in the cluster.
* The agent collects detailed metrics (CPU, memory, JVM, thread pools, API response times, etc.) from the Mule runtime.
* These metrics are then sent securely to the MuleSoft-hosted control plane, where they can be visualized in Anypoint Monitoring dashboards.
This setup ensures that the control plane has visibility into the performance of applications running in the on-prem cluster.
Why the other options are incorrect:
A. Update Monitoring settings in control plane → Control plane settings alone cannot capture metrics; the agent is required on each node.
C. Install agent on a separate server → Incorrect. The agent must run on the same node as the Mule runtime to collect JVM-level metrics.
D. No action needed → Wrong. On-prem runtimes do not automatically send detailed metrics; the agent installation is mandatory.
References:
MuleSoft Documentation: Anypoint Monitoring for Hybrid Deployments
MuleSoft Certified Platform Architect I Exam Guide — Monitoring Hybrid Runtimes
Summary: Option B is correct because the Monitoring Agent must be installed on each node in the on-prem cluster to capture and forward detailed performance metrics to the MuleSoft-hosted control plane.
What is a key requirement when using an external Identity Provider for Client Management in Anypoint Platform?
A. Single sign-on is required to sign in to Anypoint Platform
B. The application network must include System APIs that interact with the Identity Provider
C. To invoke OAuth 2.0-protected APIs managed by Anypoint Platform, API clients must submit access tokens issued by that same Identity Provider
D. APIs managed by Anypoint Platform must be protected by SAML 2.0 policies
C. To invoke OAuth 2.0-protected APIs managed by Anypoint Platform, API clients must submit access tokens issued by that same Identity Provider
Explanation:
This question focuses on the integration between an external Identity Provider (IdP) and Anypoint Platform's client management and OAuth 2.0 token validation flow.
Option C is correct. This is the core requirement and purpose of configuring an external IdP for client management. When you configure an external IdP (e.g., PingFederate, Auth0, Azure AD) in Anypoint Platform, you are delegating the role of the Authorization Server to that IdP. This means:
The external IdP is responsible for authenticating resource owners (users) and issuing access tokens.
Anypoint Platform (specifically, the API Gateway in API Manager) is configured to trust and validate access tokens issued by that specific external IdP.
Therefore, for an API client to successfully access an API protected by an OAuth 2.0 policy in Anypoint Platform, it must first obtain a token from the configured external IdP and present that token in the request.
Option A is incorrect. While Anypoint Platform supports Single Sign-On (SAML 2.0) for user logins to the platform itself, this is a separate configuration. Using an external IdP for OAuth client management (acting as an Authorization Server) does not require that the same IdP be used for user SSO into the Anypoint Platform admin console.
Option B is incorrect. This describes an API-led solution architecture, not a platform configuration requirement. The interaction between Anypoint Platform and the external IdP for token validation is an internal, configuration-level trust relationship handled by the platform's API Gateway. It does not require you to build and deploy "System APIs" to facilitate this core security function.
Option D is incorrect. This conflates two different security protocols. SAML 2.0 is primarily used for user authentication (e.g., web SSO), while OAuth 2.0 is used for authorization and securing API access. The policy you apply on an API in API Manager to leverage an external IdP is an OAuth 2.0 access token validation policy, not a SAML policy. The external IdP must support being an OAuth 2.0 Authorization Server.
Reference: This functionality is part of the "Security" domain, specifically "Apply security policies to APIs (OAuth 2.0, OpenID Connect)". The MuleSoft documentation on "Configuring an External OAuth 2.0 Token Provider" details this exact requirement and process.
A system API has a guaranteed SLA of 100 ms per request. The system API is deployed to
a primary environment as well as to a disaster recovery (DR) environment, with different
DNS names in each environment. An upstream process API invokes the system API and
the main goal of this process API is to respond to client requests in the least possible time.
In what order should the system APIs be invoked, and what changes should be made in
order to speed up the response time for requests from the process API?
A. In parallel, invoke the system API deployed to the primary environment and the system API
deployed to the DR environment, and ONLY use the first response
B. In parallel, invoke the system API deployed to the primary environment and the system API
deployed to the DR environment using a scatter-gather configured with a timeout, and then
merge the responses
C. Invoke the system API deployed to the primary environment, and if it fails, invoke the
system API deployed to the DR environment
D. Invoke ONLY the system API deployed to the primary environment, and add timeout and
retry logic to avoid intermittent failures
A. In parallel, invoke the system API deployed to the primary environment and the system API
deployed to the DR environment, and ONLY use the first response
Explanation:
This question presents a different optimization goal than the previous disaster recovery question. Here, the primary goal is the least possible response time for the Process API, and the System API has a guaranteed SLA of 100ms. The presence of a DR environment is a secondary fact to be leveraged for performance, not just resilience.
Why A is Correct:
This implements a "fastest response" or "race" pattern, which is optimal for minimizing latency when you have multiple, functionally equivalent endpoints.
- Parallel Invocation: The Process API sends requests to both the primary and DR System API endpoints simultaneously.
- Use First Response: It immediately returns the result from whichever endpoint responds first, discarding the slower response. This statistically guarantees the lowest possible latency for the client, as it eliminates the risk of the chosen endpoint being temporarily slower. It turns the DR environment into a performance asset, not just a resilience backup.
Why B is Incorrect:
Using a scatter-gather to merge responses adds unnecessary complexity and increases latency. Scatter-gather waits for all parallel routes to complete (or timeout) before proceeding to merge results. This means the response is delayed until the slowest of the two endpoints responds, which is the opposite of the goal to get the fastest possible response. It's used for aggregating different data, not for speed.
Why C is Incorrect:
This is a sequential, primary-first failover strategy. It is excellent for resilience and conserving DR capacity, but it is poor for minimizing response time. If the primary is slow (but not failing), the client still waits for the primary's timeout before even trying the DR, resulting in higher overall latency. It optimizes for reliability, not speed.
Why D is Incorrect:
Invoking only the primary with retries is the baseline approach. It does nothing to leverage the DR environment to improve speed. Timeout and retry logic adds latency on failure but doesn't improve the best-case response time. It fails to use available resources to meet the stated goal.
Trade-off Consideration:
Pattern A (Race): Optimizes for minimum latency but doubles the load on the backend systems (both primary and DR get every request). This is acceptable only if both environments are scaled to handle 100% of the traffic, which may have cost implications.
Pattern C (Failover): Optimizes for resource efficiency and resilience but accepts higher latency in failure scenarios.
Given the explicit goal of "respond in the least possible time," the race pattern (A) is the architecturally correct choice.
Implementation in Mule 4:
This can be implemented using a Scatter-Gather where each route calls a different endpoint, but with a critical difference: you would not aggregate. Instead, you would use Error Handling and Choice logic to capture the first successful response and cancel the other route, or use a custom aggregation strategy that picks the first successful result. More elegantly, it can be done with the async scope and competing callbacks.
Reference:
This pattern is known as "Parallel Request" or "Competing Consumers" in integration design. It's a standard technique for reducing latency when idempotent calls can be made to multiple identical endpoints. MuleSoft's documentation on performance optimization discusses parallel processing for reducing overall flow execution time.
A retail company with thousands of stores has an API to receive data about purchases and insert it into a single database. Each individual store sends a batch of purchase data to the API about every 30 minutes. The API implementation uses a database bulk insert command to submit all the purchase data to a database using a custom JDBC driver provided by a data analytics solution provider. The API implementation is deployed to a single CloudHub worker. The JDBC driver processes the data into a set of several temporary disk files on the CloudHub worker, and then the data is sent to an analytics engine using a proprietary protocol. This process usually takes less than a few minutes. Sometimes a request fails. In this case, the logs show a message from the JDBC driver indicating an out-of-file-space message. When the request is resubmitted, it is successful. What is the best way to try to resolve this throughput issue?
A. Use a CloudHub autoscaling policy to add CloudHub workers
B. Use a CloudHub autoscaling policy to increase the size of the CloudHub worker
C. Increase the size of the CloudHub worker(s)
D. Increase the number of CloudHub workers
C. Increase the size of the CloudHub worker(s)
Explanation
The issue is an "out-of-file-space" error on a single CloudHub worker due to the JDBC driver creating temporary disk files. Increasing the worker size (e.g., from 0.1 vCores to 1 vCore) provides more disk space, directly addressing the resource constraint.
Why not A or D? Adding more workers (horizontal scaling) doesn’t solve the disk space issue, as each worker has the same limited disk capacity. Why not B? CloudHub autoscaling cannot dynamically increase worker size; it only adds/removes workers.
Reference: MuleSoft Documentation on CloudHub worker sizing.
Prep Smart, Pass Easy Your Success Starts Here!
Transform Your Test Prep with Realistic Salesforce-MuleSoft-Platform-Architect Exam Questions That Build Confidence and Drive Success!