Salesforce-MuleSoft-Developer-II Exam Questions With Explanations

The best Salesforce-MuleSoft-Developer-II 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-Developer-II 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-Developer-II 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.

Salesforce Salesforce-MuleSoft-Developer-II Exam Sample Questions 2026

Start practicing today and take the fast track to becoming Salesforce Salesforce-MuleSoft-Developer-II certified.

2604 already prepared
Salesforce 2026 Release
60 Questions
4.9/5.0

Refer to the exhibit.

Based on the code snippet, schema,json file, and payload below, what is the outcome of the given code snippet when a request is sent with the payload?

A. The Mule flow will execute successfully with status code 200, and the response will be the JSON sent in request

B. The Mule flow will execute successfully with status code 204

C. The Mule flow will throw the exception ‘JSON:SCHEMA_NOT_HONOURED

D. The Mule flow will execute successfully with status code 200m and a response will display themessage ‘’ Age in years which must equal to or greater than zero.’’

C.   The Mule flow will throw the exception ‘JSON:SCHEMA_NOT_HONOURED

Explanation:

Let’s analyze this Mule flow step by step to determine the outcome when a request is sent with the provided payload! The exhibit shows a Mule flow named Validate-JsonFlow that listens on the /validate endpoint, processes a JSON payload, and includes a schema validation step. We’ll examine the code snippet, the schema reference, and the payload to figure out what happens. The flow starts with an HTTP Listener configured at localhost:8081/validate, accepting a JSON payload. The payload provided is:

{
"firstName": "John",
"lastName": "Doe",
"age": -1
}

The flow includes a validate-schema component with a reference to a schema file (schema.json) located at https://example.com/person_schema.json, which also references a JSON schema draft (https://json-schema.org/draft/2020-12/schema). Additionally, there’s a logger set to log "message is processed successfully" at the INFO level. The validate-schema component checks the payload against the schema, and we need to determine if it passes or fails based on the schema rules.

The schema file isn’t fully shown, but the validate-schema component typically enforces constraints defined in the referenced schema.json. A common constraint for an age field in a person schema is that it must be a non-negative number (i.e., greater than or equal to zero). The payload has an age of -1, which violates this likely constraint. Let’s assume the schema includes a rule like "minimum": 0 for the age field, which is standard for age validation.

In Mule, the validate-schema processor checks the payload against the schema. If the payload doesn’t conform (e.g., age is -1 when it should be >= 0), it throws a JSON:SCHEMA_NOT_HONOURED exception. The flow doesn’t show an error handler to catch this, so the exception would propagate, causing the flow to fail rather than proceed to the logger or return a success status.

Now, let’s evaluate the options:

❌ A. The Mule flow will execute successfully with status code 200, and the response will be the JSON sent in request
If the schema validation fails due to age: -1, the flow won’t execute successfully—it would throw an exception instead. A 200 status implies success, which doesn’t match here. This is incorrect.

❌ B. The Mule flow will execute successfully with status code 204
A 204 status indicates a successful request with no content, but the flow would stop at the schema validation failure. Without an error handler to suppress the exception and force a 204, this isn’t the outcome. This is incorrect.

✅ C. The Mule flow will throw the exception ‘JSON:SCHEMA_NOT_HONOURED’
This aligns with the behavior of validate-schema. Since the payload’s age: -1 likely violates the schema’s minimum value constraint, the processor will raise a JSON:SCHEMA_NOT_HONOURED exception, halting the flow. This fits the scenario perfectly.

❌ D. The Mule flow will execute successfully with status code 200 and a response will display the message ‘’ Age in years which must equal to or greater than zero.’’
For this to happen, the flow would need an error handler or custom logic to catch the schema violation, log the message, and return a 200 status. The current flow lacks such a handler—it only has a logger for success. This isn’t the default behavior, so this is incorrect.

The schema validation failure due to age: -1 triggers the exception, and without an error handler to mitigate it, the flow stops. The logger won’t execute because it’s after the validation step, and no success response is sent.

✅ Answer: C
The validate-schema component checks the payload against the schema.json file. The payload’s age: -1 likely violates a schema constraint requiring age to be greater than or equal to zero, causing the validate-schema processor to throw a JSON:SCHEMA_NOT_HONOURED exception. Without an error handler, the flow fails at this point, preventing further execution.

Reference: MuleSoft Documentation on Schema Validation and Error Handling.

An API has been developed and deployed to CloudHub Among the policies applied to this API is an allowlist of IP addresses. A developer wants to run a test in Anypoint Studio and does not want any policies applied because their workstation is not included in the allowlist. What must the developer do in order to run this test locally without the policies applied?

A. Create a properties file specifically for local development and set the API instance ID to a value that is not used in API Manager

B. Pass in the runtime parameter ‘’-Danpow.platform.gatekeeper=disabled’’

C. Deactivate the API in API Manager so the Auto discovery element will not find the application when it runs in Studio

D. Run the test as-s, with no changes because the Studio runtime will not attempt to connect to API Manager

B.   Pass in the runtime parameter ‘’-Danpow.platform.gatekeeper=disabled’’

Explanation:

Correct Answer: B. Pass in the runtime parameter ‘-Danypoint.platform.gatekeeper=disabled’
When testing an API locally in Anypoint Studio, the developer can bypass API Manager policies (like an IP allowlist) by disabling the Autodiscovery feature, which connects the API to API Manager. By passing the runtime parameter -Danypoint.platform.gatekeeper=disabled in the Mule runtime configuration (e.g., in the Run Configurations of Anypoint Studio), the API runs without attempting to communicate with API Manager, thus bypassing all policies, including the IP allowlist. This approach ensures the local test ignores policies without modifying the API’s configuration or deployment settings. MuleSoft’s documentation on Autodiscovery and local testing confirms this parameter disables policy enforcement during local execution.

Incorrect Answers:

A. Create a properties file specifically for local development and set the API instance ID to a value that is not used in API Manager
Creating a properties file with a different API instance ID might prevent the API from registering with API Manager, but it’s not a reliable or recommended approach for bypassing policies during local testing. The Autodiscovery configuration still attempts to connect to API Manager unless explicitly disabled, and an invalid API instance ID could cause errors or unexpected behavior. MuleSoft’s documentation on Autodiscovery emphasizes disabling the gatekeeper for local testing rather than manipulating instance IDs.

C. Deactivate the API in API Manager so the Autodiscovery element will not find the application when it runs in Studio
Deactivating the API in API Manager prevents Autodiscovery from linking to the API, but this affects the production environment and all users, not just the local test. It’s impractical for testing purposes, as it disrupts the deployed API on CloudHub. MuleSoft’s documentation on API Manager and Autodiscovery recommends using runtime parameters like -Danypoint.platform.gatekeeper=disabled for local testing instead of altering the API’s status in API Manager.

D. Run the test as-is, with no changes because the Studio runtime will not attempt to connect to API Manager
This is incorrect because the Studio runtime will attempt to connect to API Manager if the API is configured with Autodiscovery (via the element). Without disabling Autodiscovery, the runtime enforces policies like the IP allowlist, which would block the test if the developer’s workstation IP is not allowed. MuleSoft’s documentation on Anypoint Studio and Autodiscovery clarifies that the runtime communicates with API Manager unless explicitly disabled.

Summary:
Option B is correct because passing the runtime parameter -Danypoint.platform.gatekeeper=disabled disables Autodiscovery in Anypoint Studio, preventing API Manager policies (e.g., IP allowlist) from being applied during local testing. Options A (modifying API instance ID), C (deactivating the API), and D (running as-is) are incorrect because they either don’t reliably bypass policies or disrupt the production environment.

References:
MuleSoft Documentation: Configure Autodiscovery (docs.mulesoft.com) – Explains the -Danypoint.platform.gatekeeper=disabled parameter for disabling policy enforcement in local environments.
MuleSoft Documentation: Testing in Studio (docs.mulesoft.com) – Notes that Autodiscovery connects to API Manager by default unless disabled via runtime parameters.
MuleSoft Documentation: API Manager Policies (docs.mulesoft.com) – Describes how policies like IP allowlists are enforced via Autodiscovery, requiring explicit disabling for local testing.

When registering a client application with an existing API instance or API Group instance, what is required to manually approve or reject request access?

A. To configure the SLA tier for the application and have the role of Organization Administrator, API Manager Environment Administrator, or the Manage Contacts permission

B. To configure the SLA tier for the application and have the Exchange Administrator permission

C. To configure the SLA tier for the application

D. To only have Exchange Administrator permission

A.   To configure the SLA tier for the application and have the role of Organization Administrator, API Manager Environment Administrator, or the Manage Contacts permission

Explanation:

✅ Correct Answer: A.

To configure the SLA tier for the application and have the role of Organization Administrator, API Manager Environment Administrator, or the Manage Contracts permission.

When a client application is registered to access an API (or API Group) in API Manager, and that API has an SLA-based policy (rate limiting or tiered access), approval may be manual or automatic depending on SLA settings.

If manual approval is configured for an SLA tier, someone must approve or reject the access request for the client app. The person doing this must have specific roles or permissions in the Anypoint Platform.

🔐 Required to approve/reject SLA access requests:
➝ The SLA tier must be configured on the API.
➝ The person approving must have one of the following roles/permissions:
➥ Organization Administrator
➥ API Manager Environment Administrator
➥ Manage Contracts permission for the specific API

❌ Incorrect Options:

B. Exchange Administrator
🔸 Wrong: Exchange permissions allow publishing/viewing APIs in Exchange. They don’t allow approving SLA requests in API Manager.

C. To configure the SLA tier for the application
🔸 Wrong: SLA configuration alone does not enable manual approval. It must be configured AND approved by someone with the right permission.

D. To only have Exchange Administrator permission
🔸 Wrong: Exchange Admin has nothing to do with SLA approvals or API Manager actions.

🔗 Reference:
MuleSoft Docs – Managing API Contracts
Access Requirements for SLA Approval

Which statement is true when using XML SDK for creating custom message processors?

A. Properties are fields defined by an end user of the XML SDK component and serve as a global configuration for the entire Mule project inwhich they are used

B. An XML SDK provides both inbound and outbound operations

C. Operations can be reused in recursive calls

D. All operations are public

A.   Properties are fields defined by an end user of the XML SDK component and serve as a global configuration for the entire Mule project inwhich they are used

Explanation:

✅ Correct Answer: A. Properties are fields defined by an end user of the XML SDK component and serve as a global configuration for the entire Mule project in which they are used
In MuleSoft’s XML SDK, properties are defined by the end user of a custom XML SDK component (module) and act as global configuration parameters for the entire Mule project. These properties, specified in the module’s XML configuration, allow users to set values (e.g., API keys, connection details) that are accessible across all operations within the module in the project. This makes them ideal for defining reusable, project-wide settings. MuleSoft’s documentation on the XML SDK (Mule 4) explains that properties are user-defined fields in the module’s XML descriptor, used to configure the module globally for the Mule application.

❌ Incorrect Answers:

❌ B. An XML SDK provides both inbound and outbound operations
The XML SDK in MuleSoft is designed to create custom modules with operations (message processors) and configurations, but it does not inherently provide both inbound and outbound operations. Inbound operations (e.g., listening for incoming messages) are typically handled by connectors or sources, while XML SDK modules focus on processing operations (e.g., transformations or API calls). Creating inbound operations requires specific source implementations, which are not a default feature of the XML SDK. MuleSoft’s XML SDK documentation clarifies that modules are primarily for custom operations, not automatically for inbound/outbound message flows.

❌ C. Operations can be reused in recursive calls
The XML SDK does not natively support recursive calls for operations within a module. While operations can be reused across flows in a Mule application, recursive calls (an operation calling itself) are not supported due to the risk of infinite loops and stack overflow issues in the Mule runtime. MuleSoft’s documentation on XML SDK module development warns against recursive patterns and recommends alternative designs, such as iterative processing, to achieve similar functionality.

❌ D. All operations are public
Not all operations in an XML SDK module are inherently public. The visibility of operations depends on their definition in the XML SDK module. Operations can be marked as internal (private) to restrict their use within the module, or public to allow external access in Mule flows. MuleSoft’s XML SDK documentation specifies that developers control operation visibility through the module’s XML configuration, allowing for both public and internal operations.

Summary:
Option A is correct because XML SDK properties are user-defined fields that provide global configuration for a Mule project using the custom module. Options B (inbound/outbound operations), C (recursive calls), and D (all operations public) are incorrect because the XML SDK does not inherently provide inbound/outbound operations, does not support recursive calls, and allows control over operation visibility.

ℹ️ References:
MuleSoft Documentation: XML SDK – Describes properties as user-defined global configuration fields for XML SDK modules.
MuleSoft Documentation: Create a Custom Module Using XML SDK – Clarifies that modules focus on custom operations, not necessarily inbound/outbound flows, and details operation visibility control.
MuleSoft Help Center: XML SDK Development – Notes that recursive calls are not supported and recommends alternative approaches for complex processing.

A scatter-gather router isconfigured with four routes:Route A, B, C and D. Route C false.

A. Error,errorMesage.payload.results [‘2’]

B. Payload failures[‘2’]

C. Error,errorMessage,payload.failures[‘2’]

D. Payload [‘2’]

C.   Error,errorMessage,payload.failures[‘2’]

Explanation:

The scatter-gather router in Mule 4 executes all routes concurrently and collects their responses. If a route fails (e.g., Route C), the router can be configured with a target variable to store results and failures, or it can throw an error that can be caught in an error handler. The aggregated payload typically contains a results array for successful responses and a failures array for failed routes, indexed by the route’s position. Let’s evaluate the options:

Option A: Error, errorMessage.payload.results[‘2’]
This suggests accessing the results array within an errorMessage.payload, which contains successful route outputs. However, if Route C fails, its entry in the results array would be null or undefined, not an error detail. This option is incorrect because it looks for a result where a failure occurred.

Option B: Payload.failures[‘2’]
This attempts to access the failures array directly from the payload. While the payload can contain a failures array when failures occur, this syntax is incomplete. In Mule 4, when an error is thrown (e.g., in a default error handler), the failure details are typically accessed via the error object (e.g., error.errorMessage.payload.failures), not just payload.failures alone. This option lacks the proper context and is incorrect.

Option C: Error, errorMessage, payload.failures[‘2’]
This is the correct approach. When a scatter-gather route fails and an error is raised (e.g., caught in a Try scope or global error handler), the error object contains an errorMessage with a payload. This payload includes a failures array that lists details of failed routes, indexed by their position (0 for A, 1 for B, 2 for C, 3 for D). The expression error.errorMessage.payload.failures[‘2’] accesses the failure details for Route C, which aligns with the scenario where Route C failed. The comma-separated format (e.g., "Error, errorMessage, payload.failures[‘2’]") may be a stylistic choice in the question, but it implies the full path to the failure data. Behavior: If Route C fails (e.g., due to a connectivity issue or invalid data), the failures[‘2’] entry would contain the error details (e.g., error type, message), while results[‘2’] would be null.

Option D: Payload[‘2’]
This suggests accessing the payload directly at index 2, which might imply the aggregated payload’s structure. However, the scatter-gather payload is an object with results and failures arrays, not a simple list indexed directly. Accessing payload[‘2’] would not reliably target the failure for Route C and is incorrect without the proper failures context.

Detailed Behavior

Scatter-Gather Operation:
The router runs Routes A, B, C, and D in parallel. If Route C fails, the scatter-gather can either:
Continue and aggregate results/failures (if configured with target or no error propagation). Throw an error (if set to fail on any route failure), which can be caught to inspect failures.
Failure Handling:
When an error is handled, the error.errorMessage.payload contains a structure like:
results:
Array of successful route outputs (e.g., [resultA, resultB, null, resultD]). failures: Array of error details for failed routes (e.g., [null, null, {error: "Route C failed"}, null]).
Indexing:
The index [‘2’] corresponds to Route C, the third route, making failures[‘2’] the relevant data point for its failure.

Key Considerations for the MuleSoft Developer II Exam

Scatter-Gather Router:
Understand its parallel execution and aggregation of results/failures.
Error Handling: Know how to access error details using the error object, especially error.errorMessage.payload.failures.
Payload Structure:
Recognize the results and failures arrays in the scatter-gather output.
Configuration:
Be aware that scatter-gather behavior (e.g., failing on error) depends on settings like failOn="ANY".

Prep Smart, Pass Easy Your Success Starts Here!

Transform Your Test Prep with Realistic Salesforce-MuleSoft-Developer-II Exam Questions That Build Confidence and Drive Success!

Frequently Asked Questions

The MuleSoft Developer II Exam is an advanced certification designed for experienced MuleSoft developers who build and manage complex integrations using Anypoint Platform. It validates expertise in designing scalable APIs, implementing advanced DataWeave transformations, applying error handling strategies, and deploying Mule applications across CloudHub and on-premise environments.
The exam covers several core domains:

Anypoint Platform Development (25%): Building Mule applications using Anypoint Studio, managing connectors, and working with flows, subflows, and private flows.

API Design and Development (20%): Designing RESTful APIs with RAML, applying API-led connectivity principles, and managing API lifecycle through Anypoint Exchange.

DataWeave Transformations (20%): Writing advanced DataWeave scripts to transform, map, and manipulate complex data structures including JSON, XML, and CSV formats.

Error Handling and Debugging (15%): Implementing robust error handling strategies, using Mule debugger, and managing exceptions across synchronous and asynchronous flows.

Deployment and Runtime Management (20%): Deploying applications to CloudHub, Runtime Fabric, and on-premise runtimes, and monitoring performance through Anypoint Monitoring.
Number of questions: 60 multiple-choice/multiple-select questions
Time allowed: 120 minutes
Passing score: 70%
To prepare effectively, start by completing the MuleSoft Developer I certification if you have not already, as it covers foundational concepts that this exam builds upon. Use MuleSoft official training courses, particularly the "Anypoint Platform Development: Advanced" course, and practice hands-on development in Anypoint Studio. Focus heavily on DataWeave scripting and real-world API design scenarios. Additionally, practice exams from SalesforceKing can help you assess your readiness, identify weak areas, and get comfortable with the exam question format before test day.
The MuleSoft Developer II exam is considered one of the more challenging Salesforce certifications due to its advanced technical depth. MuleSoft recommends:

1+ year of hands-on experience building integrations with Anypoint Platform
Prior completion of the MuleSoft Developer I certification
Strong proficiency in DataWeave 2.0 and API-led connectivity design patterns
Familiarity with CloudHub deployment, Runtime Manager, and Anypoint Monitoring tools
SalesforceKing provides up-to-date practice tests for MuleSoft Developer II Exam, covering all key domains including DataWeave transformations, API design, error handling, and CloudHub deployment. The practice tests include real-world integration scenarios and hands-on style questions that closely mirror the actual exam format, helping candidates familiarize themselves with question styles, sharpen their technical knowledge, and identify gaps in understanding for targeted and efficient study.
Yes, candidates using SalesforceKing MuleSoft Developer II practice tests are reported to have a 90-95% first-attempt pass rate, compared to 50-60% for those without practice tests. The platform questions simulate the actual exam environment, improve time management under pressure, and boost confidence by clearly highlighting strengths and weaknesses, allowing for focused preparation and significantly reducing the likelihood of costly exam retakes.