• Cert++
  • Practice
  • Certle
  • Review
  • Tracks
  • Checklist
  • Guides
  • Upgrade
Cert++
  1. Home
  3. MuleSoft Developer

MuleSoft Developer

Checklist progress

0/159Learned

MuleSoft Developer

Study Checklist

  • Platform Administrator
  • Platform App Builder
  • Platform Foundations
  • Platform Developer
  • Platform Administrator II
  • Agentforce Sales Consultant
  • Agentforce Service Consultant
  • Platform Data Architect
  • Platform Development Lifecycle and Deployment Architect
  • Platform Identity and Access Management Architect
  • Platform Integration Architect
  • Platform Sharing and Visibility Architect
  • Heroku Architect
  • B2C Solution Architect
  • Experience Cloud Consultant
  • Agentforce Field Service and Operations Consultant
  • Agentforce Nonprofit Consultant
  • Data 360 Consultant
  • Omnistudio Consultant
  • CRM Analytics and Einstein Discovery Consultant
  • Platform User Experience Designer
  • Platform Strategy Designer
  • B2C Commerce Developer
  • JavaScript Developer
  • Omnistudio Developer
  • Platform Developer II
  • Marketing Cloud Engagement Administrator
  • Marketing Cloud Engagement Specialist
  • Marketing Cloud Engagement Consultant
  • Agentforce Sales Foundations
  • Business Analyst
  • Marketing Cloud Engagement Developer
  • Marketing Cloud Engagement Foundations
  • Agentforce Specialist
  • Agentforce Life Sciences Consultant
  • B2B Commerce Administrator AP
  • B2B Commerce Developer AP
  • Agentforce Consumer Goods AP
  • Agentforce Financial Services AP
  • Agentforce Health AP
  • Agentforce Manufacturing AP
  • MuleSoft Integration Foundations
  • MuleSoft Developer
  • MuleSoft Developer II
  • MuleSoft Platform Integration Architect
  • MuleSoft Platform Architect
  • Tableau Desktop Foundations
  • Tableau Data Analyst
  • Tableau Consultant
  • Tableau Server Administrator
  • Tableau Architect

Checklist progress

0/159Learned

  • Given a description of reusable, discoverable, network-accessible building blocks exposed via APIs, identify that it describes an Application Network and its central goal of composability/reuse.
  • Identify the defining characteristics of a modern API (well-defined, documented in Exchange, productized, secured, managed, versioned, reusable) versus a traditional point-to-point integration.
  • Given a scenario where business changes require fast delivery, explain how an Application Network increases the speed of delivery through reuse and self-service consumption of existing APIs.
  • Identify the named benefits an Application Network delivers to an organization (increased speed/agility, decentralized self-service access, increased operational efficiency/reuse).
  • Match each Application Network benefit to a described business situation.
  • Identify the primary role of Design Center and Anypoint Studio in building an Application Network.
  • Identify the primary role of Anypoint Exchange in building an Application Network.
  • Identify the primary role of API Manager and Runtime Manager in building an Application Network.
  • Classify an API as System, Process, or Experience layer given its responsibilities (unlock data from systems of record, orchestrate/aggregate business logic, or tailor data for a specific consuming channel).
  • Given a requirement to expose data differently to a mobile app versus a partner, identify that Experience APIs provide channel-specific representations while reusing the same Process/System APIs.
  • Explain why API-led connectivity reduces point-to-point integration and increases reuse compared to a monolithic or SOA-only approach.
  • Identify which connectivity layer a new API belongs in when it aggregates data from multiple System APIs to fulfill a business process.
  • Recognize that System APIs insulate consumers from changes to underlying systems of record (e.g., swapping a database or SaaS backend) without changing Process/Experience APIs.
  • Identify the typical ownership and rate-of-change profile of System APIs (central IT, stable/low change).
  • Identify the typical ownership and rate-of-change profile of Experience APIs (front-end/channel team owned, frequent change).
  • Identify the purpose of a Center for Enablement (C4E): a cross-functional team that promotes asset reuse, self-service, and federated delivery rather than centralized building of all integrations.
  • Configure an HTTP Request operation method and path to consume a RESTful service and predict the resulting outbound request.
  • Configure HTTP Request query parameters and URI parameters and predict the exact outbound URL sent to the service.
  • Configure HTTP Request headers when consuming a RESTful service and predict their effect on the request and response payload type.
  • Distinguish HTTP:CONNECTIVITY errors from HTTP client/server error types raised when consuming a REST service fails.
  • Given an Exchange-published REST connector with required parameters, identify the correct configuration to authenticate and invoke an operation, and predict the response binding.
  • Predict the parsed payload MIME type/data type of an HTTP Request response based on the response Content-Type header (e.g., application/json parsed lazily into a Java/DataWeave structure) and how it is consumed downstream.
  • Map CRUD operations to the correct HTTP methods (GET/POST/PUT/PATCH/DELETE) for a given resource action.
  • Identify which HTTP methods are safe and/or idempotent for a given REST operation.
  • Predict the appropriate 4xx client error status code (400, 404, 405, 409) for a given client or request error.
  • Distinguish full-replacement (PUT) versus partial-update (PATCH) versus create (POST) semantics for a given update requirement and choose the correct method.
  • In RAML, declare query parameters with types/required/defaults and predict validation when a required query parameter is missing.
  • Define request and response bodies with media types and example/schema in RAML, and predict how APIkit validates an incoming payload against the schema.
  • Define multiple responses (status codes with bodies) for a method in RAML and predict which response definition documents a given outcome.
  • Define reusable RAML data types (types: with properties, required flags, enums, facets) and predict how the type constrains a request/response body and is used in examples.
  • Predict how a query parameter declared with enum/pattern/minimum-maximum facets is validated, and the error returned when a value falls outside the constraint.
  • Use RAML !include to reference external fragments and predict the effective merged API definition.
  • Generate a REST connector from a RAML spec in Exchange and predict the operations/inputs exposed when calling the service from another Mule app.
  • Predict how the Anypoint Platform mocking service / API Console returns example responses for a RAML so a client can call the service before an implementation exists.
  • Predict the value of payload after a Set Payload / Transform Message, including how the previous payload is replaced and its MIME type.
  • Given a chain of processors, predict how payload mutates as it passes through each (immutability of the Mule event, new event per processor).
  • Use DataWeave field selectors (.field) and index selectors ([index]) on the payload and predict the result for nested or array data.
  • Use DataWeave wildcard (.*) and deep-selector (..) expressions on the payload and predict the result.
  • Predict null-safe selector (.?) behavior when accessing a field that may be absent on the payload.
  • Predict the result of applying a key/index selector to a payload whose data type does not support it (e.g., indexing a string-typed payload, selecting a field on an array) including the resulting error or null.
  • Access inbound attributes (e.g., attributes.queryParams, attributes.headers, attributes.uriParams) for an HTTP listener and predict their values for a given request.
  • Predict how attributes are replaced when a new source/operation sets attributes (e.g., after an HTTP Request or DB select) and that attributes are read-only via expression.
  • Given attributes.queryParams accessed with a key that may be absent, predict null vs error behavior and the correct null-safe access.
  • Predict how variables set with Set Variable persist across processors within the same flow.
  • Predict whether variables propagate back to the caller after a Flow Reference to a subflow or flow completes.
  • Predict the effect of Remove Variable and reassigning a variable on subsequent processors.
  • Predict how the target (Target Value / Target Variable) parameter on an operation stores the operation result into a variable instead of overwriting the payload.
  • Given an operation with a target and a Target Value expression referencing 'payload', predict what is stored in the target variable versus the main event payload.
  • Compare enriching with target parameter vs using Set Variable after the operation, and predict differences when the operation fails.
  • Given environment-specific values, design property placeholders with a Configuration Properties file and predict resolution order/override behavior across environments.
  • Predict the outcome of using secure properties vs plain configuration properties, including when encrypted values are decrypted at runtime.
  • Distinguish static property placeholder syntax ${prop} (resolved once at startup) from DataWeave expression syntax #[...] (evaluated per event), and predict which is required to reference a property value versus runtime event data.
  • Predict how the secure::prefix is used to reference an encrypted property and the requirement to supply the decryption key (e.g., via system property/-M-Dkey) at runtime.
  • Decide when to split global elements/connector configs into a separate config XML file imported into the main app, and predict load behavior.
  • Predict failures when a referenced property key is missing or a property file is not loaded at startup.
  • Distinguish flow vs subflow processing strategy and thread context when invoked via Flow Reference.
  • Distinguish flow vs subflow error-handling ownership when invoked via Flow Reference.
  • Distinguish flow vs subflow transaction context when invoked via Flow Reference.
  • Predict whether the payload/vars/attributes are shared back to the caller after a Flow Reference returns, for both flows and subflows.
  • Compare passing events synchronously via Flow Reference versus asynchronously via VM connector queues, and predict ordering/decoupling/transaction outcomes.
  • Predict error propagation differences when a referenced subflow (no own error handling) versus a referenced flow (own error handler) throws an error.
  • Given a spec, manually wire HTTP Listener routes to flows matching each method+resource and predict routing for an incoming request.
  • Predict the flows APIkit Router generates from a RAML (a main flow + one flow per method:resource:mediaType) and how requests are dispatched.
  • Predict APIkit behavior when the request URI does not match any RAML resource (APIKIT:NOT_FOUND).
  • Predict APIkit behavior when the HTTP method is not defined for the resource (APIKIT:METHOD_NOT_ALLOWED).
  • Predict APIkit behavior when the request payload fails RAML schema validation (APIKIT:BAD_REQUEST).
  • Predict APIkit behavior when the requested Accept/media type is not supported (APIKIT:NOT_ACCEPTABLE).
  • Predict the structure APIkit scaffolds: a main flow containing the HTTP Listener + APIkit Router + APIkit error handler (console flow), and predict how an incoming request flows from listener to router to the matching method:resource flow.
  • Given RAML-defined responses, build a flow that returns the correct status code, headers, and body shape, and predict the client-visible response.
  • Predict how APIkit's error mappings translate Mule errors into the HTTP status codes/bodies declared in RAML.
  • Configure a Database Select with input parameters (:param) and predict the payload structure returned (list of maps) and how to bind values safely against SQL injection.
  • Given a parametrized vs dynamic (#[]) SQL query, predict differences in safety and behavior.
  • Identify the role of a shared connector configuration (config-ref) referenced by multiple Database operations and predict the effect of changing one connection config on all operations that reference it.
  • Given a Database Select returning a list of records, predict how to map/transform the result with DataWeave (e.g., map over rows, access columns by name) and the output structure.
  • Predict On New/Updated File listener behavior and postProcessing outcomes (moveTo, rename, autoDelete).
  • Predict payload type/streaming behavior when reading a file (binary stream) and how a subsequent DataWeave/transform consumes it.
  • Use an inline operation (e.g., HTTP Request or DB Select) with a target to retrieve data mid-flow without overwriting payload, then combine via DataWeave, and predict the merged result.
  • Predict how to combine two datasets retrieved into variables using DataWeave (joins/lookups) and the resulting structure.

Apply correct processors/syntax to process individual records in a collection using For Each scopes, and predict outcomes

0/6

  • Predict that For Each splits a collection and processes records synchronously in order.
  • Predict that For Each restores the original collection payload after the scope completes.
  • Predict the counter variable and scope-local variables exposed inside a For Each iteration.
  • Predict the value of payload inside vs after a For Each scope and the effect of batchSize on chunking.
  • Predict error behavior in For Each: an unhandled error stops iteration at the failing record.
  • Distinguish For Each (sequential, ordered, payload restored) from Parallel For Each (concurrent execution, aggregated collection result, no guaranteed order) and choose/predict the outcome under an ordering vs throughput requirement.

Apply correct processors/syntax to process individual records in a collection using batch scopes, and predict outcomes

0/5

  • Predict Batch Job phases (Load and Dispatch, Process records in steps, On Complete) and the purpose of each phase.
  • Predict how batch block size and concurrency settings affect batch job throughput.
  • Predict how acceptPolicy / acceptExpression and record-level failures route records across batch steps, and what BatchJobResult reports.
  • Compare Batch vs For Each for a large dataset requiring parallelism and resilience, and choose the right one under a given constraint.
  • Predict the payload seen inside a batch step (the individual record) versus inside a Batch Aggregator (an array of records sized by the aggregator), and how record variables (recordVars) persist across steps.

Apply correct processors/syntax to process individual records in a collection using async scopes, and predict outcomes

0/3

  • Predict that an Async scope runs its processors on a separate thread while the main flow continues without waiting.
  • Predict payload and variable visibility between an Async scope and the main flow after the Async scope starts.
  • Predict error handling for an Async scope (errors do not propagate to the main flow) versus synchronous processing.

Apply correct processors/syntax to process individual records in a collection using DB listeners, and predict outcomes

0/1

  • Predict how watermark and idColumn settings prevent reprocessing the same rows across poll cycles.

Apply correct processors/syntax to process individual records in a collection using messaging queues, and predict outcomes

0/1

Compare VM queues (in-app), JMS, and Anypoint MQ for decoupling and choose appropriately under a durability/cross-app constraint.

Learn this concept
Unseen

Apply correct processors/syntax to persist data between flow executions

0/2

  • Predict Object Store TTL and persistent versus transient store behavior for sharing state across flow executions or workers.
  • Predict failure/default behavior when retrieving a key that does not exist from an Object Store.
  • Predict the output of changing the DataWeave output directive (output application/json vs application/xml vs application/csv) on the same input data.
  • Predict the result of coercing types with 'as' (e.g., "123" as Number, string as Date with format) including failures for invalid coercions.
  • Predict the result of read() and write() functions (and reader/writer properties such as header, separator, indent) when explicitly parsing or serializing data to a different format within a script.
  • Predict the output of the map function on a given input array or collection.
  • Predict the output of the mapObject function on a given input object.
  • Predict the output of the filter function on a given input collection.
  • Predict the output of the pluck function on a given input object or array.
  • Predict the output of the groupBy function on a given input collection.
  • Predict the output of the distinctBy function on a given input collection.
  • Predict the output of the orderBy function on a given input collection.
  • Predict the result of the reduce function with an accumulator, including initial value behavior on empty arrays.
  • Predict the output of DataWeave string functions (joinBy, splitBy, contains) for given inputs.
  • Predict the output of DataWeave array functions (sizeOf, flatten) for given inputs.
  • Predict the result of the ++ (concatenation/merge) and - (removal) operators on arrays and objects, including key-merge behavior when concatenating objects with duplicate keys.
  • Predict the output of conditional object fields ((key: value) if condition) and how a field is omitted from the output when its condition is false.
  • Write a transformation that filters, orders (orderBy), and reshapes records, and predict the exact output JSON/structure.
  • Predict the output of formatting numbers/dates with 'as ... {format: ...}' and locale-sensitive formatting.
  • Predict the result of conditional logic (if/else, match/case, default) and null handling (default operator, null-safe selectors) in a transformation.
  • Predict the result of using the Mule module's lookup() function in DataWeave to invoke a flow and embed its returned payload.
  • Identify constraints/import required (import * from dw::Mule) and predict behavior when the called flow errors.
  • Predict scope/visibility of variables and functions defined in the DataWeave header (var, fun) and reuse via imported modules (import).
  • Predict the output of a recursive or higher-order DataWeave function and the effect of parameter typing.
  • Predict which Choice route executes given multiple when expressions and the otherwise/default route, including when no condition matches and no default exists.
  • Predict payload/route outcome when Choice when expressions are evaluated in order and only the first true branch runs.
  • Predict the aggregated result structure of Scatter-Gather (a map keyed by route index with payload/attributes) and that routes execute in parallel.
  • Predict Scatter-Gather error behavior: any failed route causes an aggregated MULE:COMPOSITE_ROUTING error containing successes and failures.
  • Compare Scatter-Gather (parallel, all routes) with Choice router and choose correctly under a given routing requirement.
  • Compare Round-Robin and First Successful routers with Scatter-Gather and choose correctly under a given requirement.
  • Predict the error type/behavior raised by the Validation module (e.g., isTrue, isNotNull, VALIDATION:* errors) when a validation fails versus passes.
  • Predict how a custom validation message and error type propagate to an error handler.
  • Predict when a configured global/default error handler is invoked versus a flow-level error handler, including precedence.
  • Predict behavior when a flow has no error handler and a default/global error handler is (or is not) configured.
  • Predict the difference between On Error Continue (flow is treated as successful, returns handler result) and On Error Propagate (error re-thrown to caller, flow fails) for the response and the caller.
  • Given a Flow Reference whose target flow uses On Error Continue vs Propagate, predict what the calling flow sees.
  • Predict which error scope matches given multiple on-error blocks with different error type/when conditions evaluated top to bottom.
  • Predict matching for parent vs child error types (e.g., HTTP:CONNECTIVITY vs MULE:CONNECTIVITY vs ANY) in ordered handlers.
  • Predict the values available on the error object inside an on-error block (error.errorType, error.description, error.cause).
  • Predict how error.errorMessage is referenced in DataWeave to build a custom error response payload.
  • Predict Try scope behavior with its own error handler: error is handled locally, and predict payload after the Try when using continue vs propagate inside it.
  • Predict Try scope transactional behavior (transactionalAction) and rollback outcomes when an error occurs.
  • Predict the effect of Error Mapping on an operation (mapping a source error type to a custom namespace:TYPE) and how downstream handlers then match it.
  • Predict how Raise Error throws a custom error type/description and how it is caught by an on-error block.
  • Predict the outcome of an MUnit test using Set Event to seed payload, attributes, or variables before invoking a flow.
  • Predict the outcome of Mock When intercepting a processor combined with Assert That or Assert Equals on the flow result.
  • Predict how Mock When intercepts a processor by name/attributes and what the test sees when the real connector is not invoked.
  • Predict MUnit spy and verify behavior for confirming processor invocations during a test.
  • Predict MUnit test failure when an assertion or expected error does not match actual results.
  • Given a DataWeave coercion or expression error in a stack trace, identify the most likely root cause.
  • Predict how the Anypoint Studio debugger/visual breakpoints expose payload/vars/attributes at a step to locate a fault.
  • Predict what a Logger component with a given DataWeave message expression outputs to the application log at a configured level, and how log output helps isolate the failing processor.
  • Predict CloudHub deployment outcomes for worker size and worker count settings.
  • Predict the effect of application properties, secure properties, and Mule runtime version on CloudHub deployment.
  • Predict CloudHub persistent queues and static IP feature behavior for deployed applications.
  • Predict CloudHub worker scaling and application logging behavior for deployed applications.
  • Predict how environment-specific properties are supplied at CloudHub deploy time.
  • Identify the available ways to deploy a Mule application to CloudHub (Anypoint Studio, Runtime Manager UI uploading the deployable archive, Mule Maven plugin, Anypoint CLI) and the deployable artifact (.jar) each uses.
  • Predict how Runtime Manager properties set on a deployed application override packaged property values and require a redeploy/restart to take effect.
  • Compare deploying an API proxy versus using API Autodiscovery (embedding the API instance ID/gateway in the running app) and choose the right approach under a constraint.
  • Predict what is required for autodiscovery to bind a deployed Mule app to its API Manager instance (apiId, gateway, credentials/connected app) and the outcome if misconfigured.
  • Predict the runtime effect of Client ID enforcement and OAuth policies on API requests.
  • Predict the runtime effect of Rate Limiting and SLA tier policies on API requests.
  • Predict API policy ordering and which policy evaluates first when multiple policies apply to an API.
  • Predict how SLA tiers gate client access to API resources.

Prepare for the Exam

Play Today's Certle
Back to track

Study Community

Ask questions and get the latest info from other MuleSoft Developer studiers. 593 members and growing.

Go to Discord

Compare VM queues (in-app), JMS, and Anypoint MQ for decoupling and choose appropriately under a durability/cross-app constraint.

Explainer

Learn More

Practice Question

Keep going

Next conceptPredict Object Store TTL and persistent versus transient store behavior for sharing state across flow executions or workers.

Checklist progress

0/159 (0%)

0 of 159 concepts learned

Tip: You can filter concepts by status.

Prepare for the Exam

Play Today's Certle
Back to track

Study Community

Ask questions and get the latest info from other MuleSoft Developer studiers. 593 members and growing.

Go to Discord

Explainer

Message queues decouple application components by allowing them to communicate asynchronously without needing to be active simultaneously. Choosing the right queue depends on whether you need in-app performance, cross-application communication, or strict durability guarantees. MuleSoft provides VM queues, JMS, and Anypoint MQ, each optimized for different deployment and reliability constraints.

Core information
  • VM queues act as in-app decoupling mechanisms that buffer messages between flows within the same Mule application or cluster.
More details and nuances
  • VM queues are shared, cluster-wide resources that enable optimal performance and automatic load balancing across all active nodes in a cluster.