Salesforce Certified MuleSoft Developer II (Mule-Dev-301) Exam Topics and Questions
These Salesforce Certified MuleSoft Developer II (Mule-Dev-301) exam topics are organized according to official exam domains to help candidates quickly verify coverage and focus on assessment rather than theory. Each domain is paired with topic-wise Salesforce Certified MuleSoft Developer II (Mule-Dev-301) sample questions that reflect how objectives are tested in the actual exam. This structure enables efficient review, targeted self-assessment, and rapid identification of weak areas when preparing for the Salesforce Certified MuleSoft Developer II certification exam.
Let's Practice Free Salesforce Certified MuleSoft Developer II (Mule-Dev-301) Questions Aligned with Official Exam Topics
This topic sits at the boundary between your Mule runtime and the Anypoint Platform control plane. You need to register your API implementation so that the platform can apply policies, track usage, and enforce contracts. The cost comes when versioning breaks a consumer, when a policy misconfiguration blocks valid traffic, or when auto-discovery fails silently and you deploy an unmanaged endpoint. β Webhooks and auto-discovery HTTP callbacks let a Mule application receive asynchronous notifications instead of polling. You register a...
This topic sits at the boundary between your Mule runtime and the Anypoint Platform control plane. You need to register your API implementation so that the platform can apply policies, track usage, and enforce contracts. The cost comes when versioning breaks a consumer, when a policy misconfiguration blocks valid traffic, or when auto-discovery fails silently and you deploy an unmanaged endpoint.
β Webhooks and auto-discovery
HTTP callbacks let a Mule application receive asynchronous notifications instead of polling. You register a callback URL with an external system, then handle the incoming POST in a listener flow. The challenge is validating the callback source, handling retries, and responding with the correct status code so the sender does not mark your endpoint as failed. Auto-discovery links a deployed application to an API instance in Anypoint Platform. You add the auto-discovery configuration to your application XML, referencing the API ID and optionally a version. If the ID is wrong, the application starts but policies are not applied. If the configuration is missing entirely, the runtime has no way to associate the listener with the managed API, and you lose all platform-level control.
How Expose production-ready Anypoint Platform-managed APIs from Mule applications is tested
At thirteen percent, this topic generates questions that present a scenario where an API is deployed but not behaving as expected under platform management. You are given symptoms such as policies not applying, metrics not appearing, or consumers receiving cached responses when they should not. The item asks you to identify the misconfiguration or missing step. Candidates lose marks when they confuse API specification versioning with implementation versioning, or when they assume auto-discovery happens automatically without explicit configuration. Another trap is choosing a caching policy configuration that sounds plausible but produces the wrong cache boundary, leading to data leakage between tenants or requests. The question will describe the outcome and ask what should have been configured differently. Read the scenario carefully to distinguish between what was deployed and what the platform actually sees.
The practice test includes items that present a deployed API with incomplete platform integration, then ask you to diagnose the gap. Seeing these scenarios before the exam helps you recognise the pattern of symptoms that point to a missing auto-discovery element or a policy applied at the wrong level.
The question below presents an API that is running but not enforcing the expected policy. Your task is to identify the configuration step that was skipped.
Which configurations are required for HTTP Listener to enable mTLS authentication?
At a quarter of the exam, this is the heaviest topic. It covers everything that happens in your project structure and build pipeline before the application reaches a runtime. Modular design, shared libraries, custom policies, and automated deployment all live here. The cost is high because a misconfigured POM or a missing dependency breaks the build, and a flawed deployment script pushes broken code to production. β MUnit tests and custom policies MUnit tests run during the Maven test phase....
At a quarter of the exam, this is the heaviest topic. It covers everything that happens in your project structure and build pipeline before the application reaches a runtime. Modular design, shared libraries, custom policies, and automated deployment all live here. The cost is high because a misconfigured POM or a missing dependency breaks the build, and a flawed deployment script pushes broken code to production.
β MUnit tests and custom policies
MUnit tests run during the Maven test phase. You write assertions against message payloads, variables, and error types, then mock external dependencies so tests do not require live endpoints. Execution with Maven means configuring the MUnit plugin to include or exclude test suites, set coverage thresholds, and fail the build when coverage drops. Custom API policies are packaged as policy templates, written in XML with a YAML definition file that declares configuration parameters. You build the policy with Maven, upload the template to Exchange, and then apply it in API Manager. The exam asks what goes into the YAML, how to reference configuration properties in the XML, and what happens when a policy throws an error that is not handled.
β Libraries and custom message processors
Encapsulating common functionality in libraries reduces duplication and centralises fixes. A library project packages flows, sub-flows, DataWeave modules, or Java classes, then publishes to Exchange or a private repository. Consuming applications declare the library as a Maven dependency with scope compile or provided, depending on whether the library should be bundled. Custom message processors extend Mule with new operations. The Mule SDK lets you write them in Java, exposing parameters, connection providers, and output types. The XML SDK wraps existing flows as reusable operations without Java. Both approaches require you to package the module, publish it, and then import it into an application. The exam tests whether you know which SDK to use, how to define parameters, and how to handle errors inside the custom processor so they propagate correctly.
How Implement maintainable and modular Mule applications and their Maven builds is tested
With a quarter of the marks, expect multiple items that present a build failure, a deployment failure, or a runtime error caused by a missing or misconfigured dependency. You are shown a POM snippet or a plugin configuration block and asked what needs to change. Another pattern gives you a scenario where a shared library is updated but consuming applications still use the old version, and you must identify the versioning or repository configuration mistake. Custom policy questions describe a policy that does not apply or throws an error, then ask what is wrong with the YAML definition or the XML logic. Candidates lose marks by confusing the scope of a dependency, by assuming MUnit tests run without plugin configuration, or by choosing a deployment target that does not match the plugin settings. The weight makes this topic a priority: you cannot afford to guess.
The question bank for this topic is the largest in the exam, reflecting the weight. Working through the full set helps you spot the difference between a missing exclusion and a wrong scope, and between a plugin misconfiguration and a credential issue, under the time pressure of the real test.
The scenario below describes a Maven build that completes but produces a deployment error. Identify the plugin configuration element that needs correction.
Once an application is running, you need visibility into its health and behaviour. This topic covers the instrumentation you build into the application and the external tooling you connect to it. The cost comes when a failure goes undetected because logging was insufficient, or when correlation is broken and you cannot trace a request across systems. β Log levels, aggregation and monitoring Log levels can be changed at runtime without redeployment, either through Anypoint Runtime Manager or by editing the...
Once an application is running, you need visibility into its health and behaviour. This topic covers the instrumentation you build into the application and the external tooling you connect to it. The cost comes when a failure goes undetected because logging was insufficient, or when correlation is broken and you cannot trace a request across systems.
β Log levels, aggregation and monitoring
Log levels can be changed at runtime without redeployment, either through Anypoint Runtime Manager or by editing the log4j2.xml configuration file. You raise the level to DEBUG to investigate an issue, then lower it to INFO to reduce volume. Aggregation sends logs to a central platform such as Splunk, ELK, or Anypoint Monitoring, where you can search, correlate, and visualise them. Monitoring tools track application metrics including message throughput, error rate, response time, and resource usage. Anypoint Platform provides built-in dashboards; external tools require an agent or log shipper. Message correlation assigns a unique ID to each request and propagates it across flows, HTTP calls, and JMS messages. You set the correlation ID in a variable, add it to outbound HTTP headers, and log it with every message. This lets you reconstruct the path of a single request through multiple systems. The exam tests whether you know how to persist the ID across async boundaries and how to propagate it when calling external APIs.
How Implement monitorable Mule applications is tested
Questions present a scenario where an application is running but you cannot diagnose a problem because logs are missing, correlation is broken, or the health check always returns success even when a dependency is down. You are asked what should have been logged, where the correlation ID was lost, or what the health check should have tested. Another pattern describes a performance issue and asks which metric or log entry would reveal the cause. Candidates lose marks by choosing a log level that produces too much or too little output, by assuming correlation IDs propagate automatically without explicit header or variable management, or by implementing a health check that only confirms the listener is running, not that the application can do useful work. The fifteen percent weight means you need solid coverage of logging strategy and correlation mechanics, not just familiarity with the logger component.
The practice test lets you see how monitoring and correlation questions are phrased, so you learn to distinguish between a logging configuration problem and a missing health check. Reviewing the full set before the exam builds pattern recognition for these diagnostic scenarios.
The item below describes an application that is failing intermittently, but the logs do not provide enough information to trace the failure. Determine what was missing from the instrumentation.
This is the heaviest topic on the exam. It covers everything that keeps an application running under load, recovering from transient failures, and processing messages without loss. Persistence, fault tolerance, validation, parallelisation, and caching all appear here. The cost is high because a missing retry, a wrong status code interpretation, or a scatter-gather without compensation can lose data or leave downstream systems in an inconsistent state. β Fault-tolerant HTTP invocations and validation Fault-tolerant HTTP calls require you to interpret status...
This is the heaviest topic on the exam. It covers everything that keeps an application running under load, recovering from transient failures, and processing messages without loss. Persistence, fault tolerance, validation, parallelisation, and caching all appear here. The cost is high because a missing retry, a wrong status code interpretation, or a scatter-gather without compensation can lose data or leave downstream systems in an inconsistent state.
β Fault-tolerant HTTP invocations and validation
Fault-tolerant HTTP calls require you to interpret status codes correctly and retry when appropriate. A 5xx response or a timeout should trigger a retry; a 4xx response should not, because the client error will not resolve on retry. You configure retry policy on the HTTP request operation, setting max attempts, delay, and which errors to retry. The Validation module lets you assert conditions on message content, throwing an error if the assertion fails. You validate that a variable is not null, that a string matches a pattern, or that a number is within range. Schema validation checks a JSON or XML payload against a schema document, rejecting messages that do not conform. This moves error detection earlier in the flow, preventing invalid data from reaching backend systems. The exam asks what happens when validation fails mid-flow, whether the error is recoverable, and how to return a meaningful response to the caller.
β Scatter-gather, compensation and client-side caching
Scatter-gather sends a message to multiple routes in parallel, then aggregates the responses. It improves performance when routes are independent and you need all results. Each route can succeed or fail independently. If one route fails, scatter-gather still waits for the others, then combines the results and any errors. Compensating transactions handle partial failure by undoing completed work. If route A succeeds and route B fails, you need a compensating action to reverse A's side effects, such as deleting a created record or releasing a reserved resource. You implement compensation with an error handler that inspects which routes succeeded, then calls rollback logic for each. The exam tests whether you know how to access individual route results, how to detect partial failure, and what order to execute compensating actions. Client-side caching stores API responses locally to avoid repeated calls. You cache using the Cache scope with an ObjectStore, defining a cache key from request parameters. The scope checks the store before invoking the flow inside, returning the cached value if present. You set expiration and invalidation rules. Mistakes include caching responses that should not be cached, such as user-specific data served to the wrong user, or failing to invalidate the cache when upstream data changes.
How Implement performant and reliable Mule applications is tested
At twenty-seven percent, this topic generates the most questions. Expect scenarios where a message is lost, a retry loop exhausts attempts, a scatter-gather leaves systems inconsistent, or a cache serves stale data. You are shown configuration or flow logic and asked what went wrong or what should change. Another pattern presents a performance problem and asks which technique would solve it without introducing a new failure mode. Candidates lose marks by retrying a 4xx error, by not acknowledging a queue message and causing redelivery storms, by failing to implement compensation when scatter-gather routes have side effects, or by caching with a key that does not distinguish between requests. The weight and the technical depth make this the hardest topic. You need to understand not just what each component does, but how it behaves under failure and load. Do not move on until you can explain the difference between VM persistence and Anypoint MQ, and how to recover from a partial scatter-gather failure.
This topic's weight and complexity mean you need volume. The practice test covers every combination of retry, validation, scatter-gather, and caching scenario, so you see the same failure patterns from different angles and learn to spot the root cause quickly.
The question presents a scatter-gather flow where one route fails and leaves a partially completed transaction. You need to identify the correct compensating action.
Security closes the exam. This topic covers encrypted configuration, TLS on both sides of a connection, and API authentication. At twenty per cent, it carries significant weight. The cost comes when credentials are exposed in logs or source control, when a certificate expires and breaks production traffic, or when mutual TLS is misconfigured and clients cannot connect. β Secure properties and key management Environment-dependent properties are externalised into files or a secure vault, then loaded at runtime. Sensitive values such...
Security closes the exam. This topic covers encrypted configuration, TLS on both sides of a connection, and API authentication. At twenty percent, it carries significant weight. The cost comes when credentials are exposed in logs or source control, when a certificate expires and breaks production traffic, or when mutual TLS is misconfigured and clients cannot connect.
β Secure properties and key management
Environment-dependent properties are externalised into files or a secure vault, then loaded at runtime. Sensitive values such as passwords and API keys are encrypted using a master key. The Secure Properties module decrypts them when the application starts. You need to know how to configure the decryption key, how to reference encrypted properties in your flows, and what happens if the key is wrong. Keys and certificates are created with tools such as keytool or OpenSSL, then packaged into a keystore or truststore. The keystore holds your private key and certificate; the truststore holds certificates of parties you trust. You distribute them by placing the files in the application resources or by referencing an external secure store. The exam tests whether you know the difference between a keystore and a truststore, which file format to use, and how to configure the password for each.
β HTTPS and mutual TLS
Exposing an API over HTTPS requires configuring the HTTP listener with a TLS context that references your keystore. Invoking an API over HTTPS requires configuring the HTTP request with a TLS context that references your truststore. Mutual TLS adds client authentication: the server demands a certificate from the client, and the client demands one from the server. You configure mutual TLS by enabling client authentication on the listener and providing a client keystore on the request. Both sides validate the certificate chain. Mistakes include using the wrong alias, referencing a truststore where a keystore is needed, or failing to import the CA certificate. The exam asks what happens when the client does not present a certificate, when the certificate is expired, or when the common name does not match the hostname.
β API authentication with Basic Auth and OAuth2
Basic Auth sends a username and password in the Authorization header, base64-encoded. You configure it on the HTTP request connector by providing credentials, and the connector adds the header. OAuth2 requires you to obtain an access token from an authorization server, then include it in the Authorization header as a bearer token. The HTTP connector can handle the token request automatically if you configure the token URL, client ID, and client secret. It caches the token and refreshes it when it expires. The REST connector works the same way but uses a higher-level API description. The exam tests whether you know which grant type to use, what happens when the token expires mid-request, and how to handle a 401 response by refreshing the token and retrying. Candidates lose marks by hardcoding tokens, by not configuring token refresh, or by sending Basic Auth credentials over an unencrypted connection.
How Secure data at rest and in transit is tested
Questions present a scenario where an application fails to connect because of a TLS misconfiguration, where credentials are logged in plain text, or where an OAuth2 token is not refreshed and requests start failing. You are shown configuration blocks and asked what is wrong. Another pattern describes a certificate that is about to expire and asks what needs to be updated and where. Candidates lose marks by confusing keystore with truststore, by assuming mutual TLS works without client-side configuration, by not encrypting properties that contain secrets, or by choosing Basic Auth when the scenario requires OAuth2. The twenty percent weight means security is not optional. You need to understand the full lifecycle of a certificate, the difference between server and client TLS contexts, and how token refresh works in the HTTP connector.
The practice test includes scenarios where TLS configuration is incomplete or credentials are exposed, then asks you to identify the fix. Working through these before the exam ensures you recognise the symptoms of a missing truststore or an expired token under time pressure.
The question below describes an HTTPS connection that fails during the handshake. You need to determine which certificate or configuration element is missing or incorrect.
Ready to Start Practicing?
Access all questions and start your exam preparation journey
Upgrade to Full Salesforce Certified MuleSoft Developer II (Mule-Dev-301) Exam Questions π