Free Salesforce Certified MuleSoft Developer Sample Questions

Correct answer: C — System API

• A. This layer only shapes data for a channel; it has no direct knowledge of the backend connection protocol, so it would not need to change.
• B. This layer orchestrates calls to a stable backend interface and is unaware of what protocol the underlying database uses, so it stays unaffected by the migration.
• C. This is the only layer that connects directly to the backend, so isolating the new connection protocol here is exactly what shields the other layers from the change.
• D. Requiring every layer to change would mean the architecture failed to isolate backend changes, which defeats the purpose of separating these responsibilities into distinct layers.

Correct answer: A — They should search Anypoint Exchange, since modern APIs are published there as discoverable, reusable assets that teams can browse and reuse.

• A. Anypoint Exchange is the catalog where modern, API-led assets are published and made discoverable and reusable, which is exactly what lets a new developer find and consume an existing System API instead of rebuilding it.
• B. Modern APIs published for an application network are not distributed as WSDL files on a shared drive; that describes a legacy SOAP-style discovery pattern, not API-led reuse.
• C. DNS registration resolves network addresses, not API discoverability; it plays no role in how teams find and reuse published API assets.
• D. Requiring developers to dig through another team's private repository history is the opposite of discoverability — a modern API is meant to be found and reused without needing source-level access.

Correct answers: A, B, C — Productize APIs so they are documented, discoverable, and easy for other teams to consume; Publish reusable assets to Anypoint Exchange so business units can find and reuse them; Collect adoption and reuse metrics from consumers to guide future asset investment

• A. Productizing APIs, giving them clear documentation and a consistent, discoverable interface, is one of the three core C4E activities that make reuse practical for other teams.
• B. Publishing productized assets to Anypoint Exchange is how the C4E makes reusable APIs findable and consumable across business units, driving the application network's growth.
• C. Harvesting adoption and reuse metrics from consumers lets the C4E prioritize which assets to invest in next, closing the feedback loop with the business units.
• D. Requiring central IT to author every API recreates a centralized bottleneck and contradicts the C4E's goal of distributing API-led delivery across business units.
• E. Gating Exchange access behind manual ticket approval blocks the self-service discovery the C4E is meant to enable, slowing reuse instead of accelerating it.
• F. Rebuilding integrations from scratch instead of checking Exchange for an existing asset defeats the purpose of productizing and publishing reusable APIs in the first place.

Correct answer: A — Any status code of 400 or higher, per the default validator.

• A. The default response validator on the HTTP Request operation classifies any status code of 400 or above as a failure and raises an error, covering both 4xx and 5xx responses.
• B. Treating 4xx codes as success is incorrect; the default validator raises an error starting at 400, not only at 500, so client-error responses also trigger a failure.
• C. Success codes other than exactly 200, such as 201 or 204, are still treated as success by the default validator, so this threshold is too strict to describe the actual default behavior.
• D. The default response validator evaluates the numeric status code returned by the server; it does not consult the RAML specification to decide what counts as an error.

Correct answer: A — Add an `enum` facet to the `sortOrder` query parameter listing `asc` and `desc` as the only allowed values.

• A. This is correct: the `enum` facet declares the exact set of values a parameter may take, so the parser rejects any `sortOrder` value that is not `asc` or `desc` without needing custom application logic.
• B. This is incorrect as written, because a regular expression that matches any string would not restrict `sortOrder` to the two allowed values; `pattern` could in principle be misused for this, but not with an unrestrictive expression.
• C. This is incorrect because `default` only supplies a fallback value when the parameter is omitted; it does not validate or reject values that clients actually send.
• D. This is incorrect because `required` only controls whether the parameter must be present at all; it says nothing about which values are acceptable once it is supplied.

Correct answer: A — 204

• A. This status code signals that the request succeeded and there is no body to return, which matches a delete operation that removes the resource and sends nothing back.
• B. This status code conventionally accompanies a response body describing the result, but this delete operation is defined to return no body at all.
• C. This status code indicates the request was accepted for later asynchronous processing, which does not describe a deletion that has already completed.
• D. This status code indicates the target resource did not exist, describing a failure case rather than a successful deletion of an existing order.

Correct answers: A, C, E — They are appropriate for filtering, sorting, or paginating a collection without changing which resource is addressed.; They can be marked optional by setting `required: false` on the parameter.; The `queryString` node and `queryParameters` node are mutually exclusive on the same method.

• A. This is correct because query parameters exist precisely to shape a collection response through filtering, sorting, or pagination while the underlying resource path stays the same.
• B. This is incorrect because query parameters can be declared with `required: true` or `required: false`, and many real-world filters are intentionally optional.
• C. This is correct because setting `required: false` is the standard way to mark a query parameter as optional, allowing a request to omit it entirely.
• D. This is incorrect because identifying a single specific resource instance is the role of a URI parameter embedded in the path template, not a query parameter.
• E. This is correct because the RAML 1.0 specification states that a method must use either `queryString` or `queryParameters` to describe its query, never both at once.
• F. This is incorrect because deployment platform choices like CloudHub have no bearing on RAML's design-time distinction between query parameters and URI parameters; the two concepts remain independent regardless of where an API is deployed.

Correct answer: A — The name field value from the first object in the array, now set as the entire payload

• A. Set Payload replaces the payload with the result of its configured expression, and payload[0].name evaluates to the name value of the first array element.
• B. Set Payload always replaces payload with the evaluated expression result; it does not leave the previous payload untouched.
• C. The expression targets only the first element with [0], so it does not iterate across the whole array the way a map operation would.
• D. Indexing with square brackets is standard DataWeave 2.0 syntax for accessing array elements by position.

Correct answer: A — The entire result of the HTTP Request operation, since the default Target Value expression resolves to the full response payload.

• A. When Target Value is left blank, it defaults to an expression equivalent to `#[payload]`, so the full response payload produced by the operation is what gets stored in the target variable.
• B. This is incorrect; the default Target Value expression targets the payload, not the status code specifically. Capturing only the status code would require a custom Target Value expression referencing attributes.
• C. This is incorrect because leaving Target Value at its default does not produce an empty result. A default expression is still applied and it evaluates to the operation's payload.
• D. This is incorrect because the default Target Value expression is based on the payload of the operation's result, not the response headers or attributes.

Correct answer: A — Route the current event into another flow, run its processors, and return control here once complete.

• A. This is correct: Flow Reference routes the current Mule event into the target flow, runs all of its processors synchronously, and then returns control back to the point right after the reference.
• B. This describes asynchronous messaging through a connector like VM, not Flow Reference, which invokes another flow directly rather than publishing to a queue.
• C. Exposing a flow over HTTP is the job of an HTTP Listener or an APIkit router acting as a message source, not an internal processor like Flow Reference.
• D. Automatically triggering a flow on a schedule is the role of a Scheduler source, which is unrelated to invoking a flow from within another flow.

Correct answer: A — DEBUG, because a deployment property set at deploy time overrides the default supplied by a global property.

• A. A global property only supplies a fallback value used when no higher-precedence source defines the same name, and deployment properties sit above global properties in Mule's resolution order. The deployment property set in Runtime Manager therefore wins, resolving `${logLevel}` to DEBUG.
• B. This describes the reverse of the actual precedence order; a global property is the lowest-precedence, default-style source, not one that overrides values set at deploy time. Runtime Manager's deployment property takes priority instead.
• C. A single placeholder resolves to exactly one value at runtime, so the logging configuration cannot apply two log levels simultaneously. Only the highest-precedence value is used.
• D. Sharing a property name between a global property and a deployment property is expected and supported; it is precisely how overriding a default value is meant to work. It does not cause a deployment failure.

Correct answer: A — Add two `apikit:flow-mapping` elements for the same resource and action, each with a different `content-type` attribute routing to its own flow.

• A. The `content-type` attribute on `apikit:flow-mapping` is designed exactly for this case, letting the same resource and action route to different flows based on the incoming media type.
• B. A flow is meant to contain a single router instance handling all incoming requests for its listener; adding multiple routers in one flow is not the supported mechanism for content-type-based dispatch.
• C. Splitting the resource path in the RAML changes the contract itself and no longer keeps a single resource and action, which the requirement explicitly rules out.
• D. The `flow-ref` attribute on `apikit:flow-mapping` takes a static flow name, not a dynamic DataWeave expression, so it cannot select a flow conditionally at runtime this way.

Correct answer: A — The router invokes `retrieveInvoicesFlow`, since the flow-mapping explicitly overrides the default flow name for that action.

• A. The `apikit:flow-mapping` element exists specifically to override which flow handles a given resource and action, so a GET on `/invoices` is routed to `retrieveInvoicesFlow` instead of the auto-generated flow name.
• B. The flow-mapping element is not cosmetic; it actively changes routing behavior, so the router does not fall back to the default generated flow name once a mapping is defined for that resource and action.
• C. APIkit does not chain the default flow and the mapped flow together; defining a flow-mapping replaces the routing target rather than adding an extra step.
• D. Defining a flow-mapping does not disable the method; it simply redirects that resource and action to a specific flow, so requests continue to be handled, just by a different flow.

Correct answers: B, D, F — `APIKIT:BAD_REQUEST` maps to HTTP `400`; `APIKIT:METHOD_NOT_ALLOWED` maps to HTTP `405`; `APIKIT:NOT_ACCEPTABLE` maps to HTTP `406`

• A. `APIKIT:UNSUPPORTED_MEDIA_TYPE` corresponds to HTTP 415, not 409, so this pairing is incorrect.
• B. `APIKIT:BAD_REQUEST` is the error APIkit raises for request validation failures against the RAML spec, and it maps to HTTP 400 by default.
• C. `APIKIT:NOT_FOUND` corresponds to HTTP 404 for an undefined resource path, not 400, so this pairing is incorrect.
• D. `APIKIT:METHOD_NOT_ALLOWED` is raised when a resource exists in the RAML spec but the requested HTTP method isn't defined for it, and it maps to HTTP 405 by default.
• E. `APIKIT:NOT_IMPLEMENTED` corresponds to HTTP 501, not 500, so this pairing is incorrect.
• F. `APIKIT:NOT_ACCEPTABLE` is raised when the requested representation in the `Accept` header can't be satisfied, and it maps to HTTP 406 by default.

Correct answer: A — An array of integers, one per record, indicating the number of rows each individual insert affected

• A. Bulk mode executes the insert statement once per input record and returns an array of affected-row counts, with one entry per executed statement. For a list of 500 records this produces an array of 500 integers, matching how JDBC batch execution reports results.
• B. The operation does not collapse the per-statement results into a single summary integer; it preserves one result per executed statement in the batch. A single total count would discard the per-record detail that bulk execution reports.
• C. Bulk mode does not automatically collect generated keys into a return value the way this option describes; its output is the array of affected-row counts from the batch execution. Retrieving generated keys would require separate configuration, not the default bulk result.
• D. The operation does not reduce the outcome to a single success/failure flag; each statement in the batch reports its own affected-row count. A boolean summary would hide which specific records succeeded or failed within the batch.

Correct answer: B — The existing content is replaced entirely with the new payload, since OVERWRITE is the default write mode

• A. APPEND is a selectable write mode but is not the default, so content is not appended unless the mode parameter is explicitly set to APPEND.
• B. OVERWRITE is the default write mode for the File connector's Write operation, so an existing target file is fully replaced by the new payload content.
• C. CREATE_NEW is a selectable write mode that raises FILE:FILE_ALREADY_EXISTS when the target exists, but it is not the mode applied unless explicitly configured.
• D. The Write operation does not pause for lock release by default; locking behavior is a separate, explicitly configured concern and does not describe the default write outcome.

Correct answer: A — Configure `target` on both the HTTP Request and Database Select operations to store each result in its own variable, then merge both variables into the payload with a Transform Message component.

• A. Giving each operation its own `target` variable avoids either one overwriting the other's result, and a Transform Message component can then reference both variables to build the combined payload — this is the standard mid-flow combination pattern.
• B. Chaining without targets lets the Select operation overwrite the HTTP response payload, and a SQL query string has no way to reconstruct arbitrary HTTP response data that has already been discarded.
• C. A Try scope exists to isolate and handle errors from nested components; it has no built-in feature that merges the payload outputs of the components inside it.
• D. For Each is built to iterate over a collection, and there is no collection to iterate over here; using it would not merge two independent operation results, it would just overwrite the shared variable on each pass.

Correct answer: A — It holds the sum of all processed order amounts, because variables persist across iterations and after the scope ends

• A. Variables set or modified inside a For Each scope carry their state forward across iterations and remain available after the loop finishes, which is exactly what allows an accumulator pattern like a running total to work correctly.
• B. For Each does not reset variables to their pre-loop values once it finishes; variables are not scoped exclusively to the loop's lifetime, so this reset behavior does not occur.
• C. This would be true only if the expression replaced the variable each time instead of adding to it. Since the update adds the current amount to the existing value, the variable accumulates rather than being overwritten with just the last record's amount.
• D. Flow variables modified inside a For Each scope remain accessible in the flow after the scope completes; they are not removed or scoped away once iteration ends.

Correct answers: A, B — Batch Step components pull blocks of records from the queue and can process multiple blocks concurrently on separate threads.; Records within a single block are processed sequentially through the Batch Step's configured operations.

• A. Batch Steps pull record blocks from the queue and process multiple blocks in parallel across threads, which is what allows a batch job to process large record sets efficiently rather than one record at a time end to end.
• B. Within a given block, the records are handled sequentially through the step's operations even though separate blocks run concurrently on different threads. This combination of parallel blocks and sequential in-block handling is standard Batch Step behavior.
• C. A Batch Step does not wait for the entire batch to clear the previous step before starting; blocks move forward as they become available, which is why blocks can be processed concurrently in the first place.
• D. The Load and Dispatch phase runs once at the start of the batch job to split the input into records; it is not repeated for each subsequent Batch Step, which instead operate on records already queued.
• E. Records do not process one at a time end to end through every step before the next record begins; instead, blocks of many records move through steps concurrently, which is what gives batch processing its throughput.
• F. The final report is compiled in the On Complete phase after all configured Batch Steps have finished running, not as soon as the first step completes.

Correct answer: A — Configure the `defaultValue` parameter on the Retrieve operation to `0`, which is returned when the key is absent without being persisted

• A. `defaultValue` is the Retrieve parameter built for a missing key: it returns the supplied fallback, here `0`, without ever writing that fallback into the store, so the flow keeps running with a sensible starting value.
• B. `failIfPresent` is a Store-side parameter that controls overwrite behavior for existing keys; Retrieve has no such parameter, so this configuration does not exist and would not prevent the missing-key error.
• C. Catching the error and writing an initial value would eventually work, but it requires extra error-handling logic and an additional Store call on every first run, when the built-in default-value behavior already covers the case directly.
• D. `entryTtl` governs how long stored entries remain before expiring; it is not a Retrieve-time fallback and setting it to `0` does not suppress the missing-key error.

Correct answer: A — payload.orderTotal as Number

• A. The `as` operator is the correct DataWeave mechanism for type coercion, so writing the selector followed by `as Number` converts the string value into a numeric type that supports arithmetic.
• B. `to` is not a DataWeave coercion keyword; DataWeave has no infix `to` operator for converting a value's type, so this expression does not compile.
• C. DataWeave does not use function-call syntax like `Number(...)` for type coercion; wrapping a selector in parentheses this way is not valid DataWeave syntax for changing a value's type.
• D. `cast` is not a reserved keyword or operator in DataWeave; the language reserves `as` specifically for coercing a value from one type to another.

Correct answer: A — payload.orderDate as Date {format: "dd-MM-yyyy"}

• A. The `as` operator is the correct DataWeave coercion operator, and the `{format: "dd-MM-yyyy"}` schema matches the day-month-year pattern of the source string, so the value parses into a valid `Date`.
• B. The format schema `"yyyy-MM-dd"` describes a year-first pattern that does not match the source string's day-first layout, so parsing fails against the actual data.
• C. `to` is not a valid DataWeave coercion operator; type coercion in DataWeave is expressed with `as` followed by the target type and an optional schema.
• D. This function-call style is not valid DataWeave syntax for type coercion; DataWeave expresses coercion through the `as` operator rather than a `Date.parse` function call.

Correct answer: A — [{"name": "Ana", "role": "ADMIN"}, {"name": "Cara", "role": "ADMIN"}]

• A. This is correct because `filter` evaluates the condition `$.role == "ADMIN"` against every object and keeps only the elements where that condition is true, which are the two objects whose `role` equals `ADMIN`.
• B. This is incorrect because it keeps the objects whose `role` is `USER`, which is the opposite of what the condition `$.role == "ADMIN"` selects; `filter` retains elements that satisfy the expression, not the ones that fail it.
• C. This is incorrect because it simply takes the first two elements of the input array regardless of their `role` value; `filter` evaluates the boolean condition against each element rather than truncating the array by position.
• D. This is incorrect because it takes the last two elements of the input array by position rather than evaluating each element's `role` against the condition; one of the retained objects here does not even satisfy `$.role == "ADMIN"`.

Correct answer: B — It invokes a top-level flow from inside a DataWeave script and returns that flow's resulting payload to the caller.

• A. This describes reading property placeholders such as `${propertyName}`, which is unrelated to invoking a flow from a DataWeave expression. The `lookup` function does not read configuration property files.
• B. This is correct: `lookup` executes a named top-level flow, passing a payload to it, and returns that flow's resulting payload back into the calling DataWeave script. This lets a Transform Message component trigger flow execution as part of a transformation.
• C. DataWeave scripts are not validated against a flow's input structure at design time by this function. `lookup` performs a runtime flow invocation, not a static compatibility check.
• D. Reusable DataWeave modules are created and shared through the `import` directive with `.dwl` files, which is a separate mechanism from invoking a Mule flow. `lookup` does not register or package scripts as modules.

Correct answer: A — src/main/resources/modules

• A. Custom DataWeave modules are placed in a `modules` subfolder of `src/main/resources`, which is the location the runtime scans when resolving `import modules::ModuleName` references.
• B. `src/main/java` is a Java source location and is not scanned by Mule for DataWeave module resolution, so a `.dwl` file placed there would not be importable this way.
• C. There is no standard `src/main/app` folder used for DataWeave modules in a Mule project structure, so this path does not make the module available.
• D. `src/test/resources` is scoped to test execution, not the main application classpath, so a module placed there is not available to application flows via this import.

Correct answer: A — `standardBatchFlow`, because `250` satisfies neither the empty-array condition nor the large-batch condition, so the default route runs.

• A. `sizeOf(payload.records) == 0` is `false` because the array has 250 elements, and `sizeOf(payload.records) > 1000` is also `false` because 250 does not exceed 1000, so neither `when` condition matches and the `otherwise` route runs.
• B. `sizeOf` returns the actual element count of the array regardless of streaming state; for an array of 250 elements it returns `250`, not `0`, so the empty-array condition evaluates to `false`.
• C. The router does not compare a value against thresholds to find the nearest match; each `when` condition is an independent boolean check evaluated in declared order, and `250 > 1000` simply evaluates to `false`.
• D. `sizeOf` returns a single numeric value for a given array, not a range, and a choice router only ever executes one route per event regardless of how many conditions might seem plausible.

Correct answer: B — A list containing both assigned values, such as `["EMEA", "APAC"]` in vars.region.

• A. Route completion order does not determine the merged value; each route starts from an identical copy of the event, so there is no overwrite based on finishing last.
• B. When multiple routes set the same variable to different values, Scatter-Gather merges them into a single list containing every value set across the routes.
• C. Route configuration order in the XML does not give one route precedence over another for variable merging; both values are combined rather than one being dropped.
• D. Setting the same variable name in multiple routes is valid and does not raise an error; Scatter-Gather is designed to merge such conflicting values into a list.

Correct answer: A — `matches-regex`

• A. Correct. `matches-regex` compares a string value against a configured regular expression pattern and raises a validation error if the value does not match, making it the operation used for pattern-based format checks.
• B. Incorrect. `is-not-blank-string` only confirms that a string contains non-whitespace content; it has no concept of matching a regular expression pattern.
• C. Incorrect. `validate-size` checks that a value's length or size falls within configured minimum and maximum bounds, which is unrelated to regex pattern matching.
• D. Incorrect. `is-allowed-ip` checks whether an IP address appears in a configured allow list; it does not evaluate string values against a regular expression.

Correct answer: A — Define an `<error-handler>` at the top level of the config, then reference its name from each flow's error handler

• A. Correct. Declaring a named `<error-handler>` as a top-level (global) element and referencing it from individual flows lets multiple flows reuse the same set of On-Error blocks instead of duplicating the handling logic in each flow.
• B. Incorrect. A Try scope defines its own inline error handler for the components it wraps and must be added separately to each flow; it does not create a shared, reusable configuration referenced across flows the way a global error handler does.
• C. Incorrect. A `logger` component only writes messages to the application log and has no role in catching, matching, or handling raised errors.
• D. Incorrect. Error handlers are scoped to the flow or Try/Until Successful scope where they are declared; Mule does not automatically extend one flow's error handler to unrelated flows.

Correct answer: A — None of the declared components match, so the error is treated as unhandled and propagates to the caller by default.

• A. Correct. When no on-error component in the error-handler matches the raised error's type, none of them handles it, and Mule falls back to default behavior, which logs the error and propagates it up to the calling context just as if no error-handler had matched.
• B. Incorrect. Mule never selects a handler whose type does not match the raised error just because it happens to be declared first; a component is only invoked when its type condition is satisfied.
• C. Incorrect. An unmatched error is not silently swallowed. Only on-error-continue handlers that actually match produce a successful outcome; an unmatched error still results in a failure that propagates.
• D. Incorrect. Mule does not require exhaustive coverage of every error type at deployment time; an incomplete error-handler is valid configuration and simply results in default propagation for unmatched errors at runtime.

Correct answer: A — A 200 response carrying the fallback payload set inside the on-error-continue block

• A. on-error-continue marks the error as handled and lets the flow finish as if the original request had succeeded, so the message that exits the error handler - here, the fallback payload - becomes the flow's outcome and is returned by the HTTP Listener as a successful response.
• B. A 500 response would only occur if the error propagated to the listener unhandled, which happens with on-error-propagate, not on-error-continue; continue swallows the error instead of re-raising it.
• C. on-error-continue does not close the connection or suppress the body; it produces a normal completed response built from whatever message exits the handler block.
• D. Mule does not auto-map error types to arbitrary HTTP status codes such as 404; the status returned depends on how the flow completes, and a continue handler that finishes successfully returns 200 by default.

Correct answer: A — 200 OK, because `on-error-continue` treats the flow as having succeeded unless the handler explicitly sets a different status code.

• A. On Error Continue completes the flow as if the original error never happened, so the HTTP Listener builds a normal success response. Unless the handler explicitly sets `httpStatus`, the listener sends back its default success code, 200, even though the underlying cause was a not-found condition.
• B. On Error Continue does not carry the original error's status code forward automatically; it discards the error state as part of completing the flow successfully. Preserving `HTTP:NOT_FOUND` as 404 would require the handler to set the status explicitly.
• C. There is no built-in default that maps an unset status to a server error; On Error Continue simply lets the listener fall back to its success status. A 500 response would only occur if the handler itself failed or explicitly set that code.
• D. On Error Continue keeps processing rather than aborting the transaction, and the flow still completes and returns a response to the client. The HTTP transaction is not left hanging or dropped.

Correct answer: A — The description text is meant for human-readable diagnostics and is not guaranteed to be stable, so matching logic should use `error.errorType` instead

• A. Correct. `error.description` is intended as a human-readable problem description and its exact wording can vary; matching or routing logic that needs a stable category should key off `error.errorType`, which is designed for that purpose.
• B. Incorrect. A Try scope provides its own isolated error handler, but it has no special role in generating or stabilizing the text of `error.description`; adding one would not fix inconsistent description matching.
• C. Incorrect. Mule does not randomize `error.description` between retries; the field reflects the actual problem encountered, and any variation across environments stems from genuinely different underlying conditions or messages, not randomization.
• D. Incorrect. Whether an error-handler is declared at the application or flow level affects which handler catches the error, not the stability or content of the `error.description` text used inside a script.

Correct answer: A — Right-click the project and choose Anypoint Platform > Deploy to CloudHub

• A. Anypoint Studio has a built-in Deploy to CloudHub action on the project context menu that packages the application and deploys it directly to CloudHub, prompting for deployment target and worker settings in the IDE.
• B. API Manager's proxy wizard is used to deploy a generated API proxy, not a developer's own Mule application archive, so this path does not deploy the built application.
• C. Authenticating with the Anypoint CLI lets a developer later run explicit deploy commands, but logging in alone does not deploy anything and there is no automatic sync from a Studio terminal session.
• D. Publishing to Exchange makes an asset discoverable and reusable, but Runtime Manager does not automatically deploy Exchange assets without an explicit deployment action being triggered.

Correct answer: A — Policy enforcement fails because the referenced flow must use an HTTP Listener component.

• A. Autodiscovery requires the referenced flow to use an HTTP Listener because policy enforcement relies on intercepting HTTP traffic. A JMS-sourced flow does not meet this requirement, so pairing and policy enforcement do not work correctly.
• B. Not every inbound connector satisfies the `flowRef` requirement; connectors that only use HTTP as an underlying transport, or non-HTTP connectors like JMS, are unsupported for policy enforcement. This makes the configuration invalid rather than merely non-optimal.
• C. Mule Runtime does not rewrite or convert connector types during deployment to satisfy autodiscovery requirements. The developer must point `flowRef` at a flow that already uses an HTTP Listener.
• D. An invalid `flowRef` does not create a duplicate API instance; it simply prevents the pairing and policy enforcement from functioning as intended. Analytics duplication is not a documented behavior of a misconfigured autodiscovery element.