Salesforce Certified MuleSoft Developer (Mule-Dev-201) Exam Topics and Questions
These Salesforce Certified MuleSoft Developer (Mule-Dev-201) 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 (Mule-Dev-201) 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 certification exam.
Let's Practice Free Salesforce Certified MuleSoft Developer (Mule-Dev-201) Questions Aligned with Official Exam Topics
This topic sets the conceptual frame for everything that follows. You need to show you understand why MuleSoft exists as a product category, what an application network is, and how the API-led approach differs from point-to-point integration. The weight is modest, but the ideas underpin the entire exam. β Application networks and API-led connectivity The exam expects you to recognise the principles of an application network: reusable APIs organised into experience, process and system layers. You will face questions that...
This topic sets the conceptual frame for everything that follows. You need to show you understand why MuleSoft exists as a product category, what an application network is, and how the API-led approach differs from point-to-point integration. The weight is modest, but the ideas underpin the entire exam.
β Application networks and API-led connectivity
The exam expects you to recognise the principles of an application network: reusable APIs organised into experience, process and system layers. You will face questions that ask you to identify which layer an API belongs to, or why a given architecture does or does not follow API-led principles. The focus is on the conceptual model rather than implementation detail. You also need to understand how modern APIs differ from older integration patterns, particularly around discoverability, reusability and decoupling. Questions often present a scenario and ask you to choose the approach that best aligns with API-led connectivity. The wrong answers typically describe tightly coupled or monolithic designs.
β The Centre for Enablement and consuming RESTful services
The Centre for Enablement, or C4E, is MuleSoft's recommended operating model for scaling API development across an organisation. You need to know what a C4E does, who participates, and how it supports reuse and governance. Expect questions that ask you to identify C4E activities or distinguish them from traditional IT operating models. The final sub-topic moves to the practical: consuming a RESTful web service defined in RAML. You must predict the outcome when specific processors or syntax are applied. This means knowing how to configure an HTTP request, how to pass parameters, and what the response looks like when the request succeeds or fails. The exam tests your ability to read a snippet of configuration and trace what happens at runtime.
How Creating Application Networks is tested
Seven percent translates to around four or five items. Most are scenario-based: you are given an architecture diagram or a description of an integration challenge, then asked to identify the API-led approach, pick the correct layer, or spot the principle being violated. The exam also tests your ability to predict outcomes when consuming a RESTful service. You will see a fragment of Mule configuration, often an HTTP request with parameters or headers, and you must choose what the flow does next or what error occurs. Candidates lose marks by confusing the three layers, by choosing point-to-point designs that feel pragmatic but violate API-led principles, and by misreading RAML definitions when predicting HTTP behaviour. The C4E questions are usually straightforward recognition items, but they catch people who have never worked in an organisation that uses the model.
The practice test gives you exposure to the scenario format before you pay for the exam. The PDF lets you review the architectural principles at your own pace, and the timed mode shows you whether you are spending too long on conceptual items that should take thirty seconds.
The question below asks you to apply API-led connectivity principles to a common integration scenario.
A mule project contains MySQL database dependency . The project is exported from Anypoint Studio so that it can be deployed to Cloudhub. What export options needs to be selected to create the smallest deployable archive that will successfully deploy to Cloudhub?
Where the first topic dealt with the why, this one deals with the what: the structure of a RESTful API. You need to know HTTP methods, resource naming, how parameters are passed, and how responses are shaped. The exam assumes you can read a RAML definition and predict what a valid request looks like. The three sub-topics cover the mechanics of REST: using methods and resources correctly, defining parameters and responses, and choosing between query parameters and URI parameters. The...
Where the first topic dealt with the why, this one deals with the what: the structure of a RESTful API. You need to know HTTP methods, resource naming, how parameters are passed, and how responses are shaped. The exam assumes you can read a RAML definition and predict what a valid request looks like. The three sub-topics cover the mechanics of REST: using methods and resources correctly, defining parameters and responses, and choosing between query parameters and URI parameters. The distinction between query and URI parameters is a favourite exam trap. A URI parameter is part of the path and identifies a specific resource. A query parameter filters, sorts or modifies the response. Candidates who treat them interchangeably lose marks. You also need to know which HTTP method is idempotent, which is safe, and what status codes mean in context. The exam does not ask you to write RAML from scratch, but it does expect you to read a snippet and identify what is missing, malformed or inconsistent with REST conventions.
How Designing APIs is tested
Eight percent means around five items. Most present a RAML fragment or a verbal description of an API requirement, then ask you to choose the correct method, resource path, parameter type or response code. You will see questions that give you a resource and ask which HTTP method applies, or that describe a filtering requirement and ask whether it should be a query parameter or a URI parameter. The exam also tests your ability to spot violations of REST conventions: using POST where PUT is correct, returning 200 when 201 is appropriate, or placing a filter in the URI when it belongs in the query string. Candidates lose marks by confusing idempotency with safety, by choosing URI parameters for optional filters, and by picking status codes that feel right but do not match the HTTP specification. The questions are usually short, but they require precise knowledge of REST semantics.
A question bank helps you see how the exam phrases REST design questions. The practice test shows you the difference between items that test method selection and those that test parameter placement, so you can target your weak area without rereading the entire RAML specification.
The question that follows tests your understanding of when to use a URI parameter versus a query parameter in a RESTful API.
What payload is returned by a Database SELECT operation that does not match any rows in the database?
This is the heaviest topic on the exam and the one that separates candidates who have built flows from those who have only read about them. Every Mule event has a payload, attributes and variables. You need to know how to access each, how to modify each, and what happens when you do. The exam tests your ability to read DataWeave expressions and processor configurations, then predict the outcome. β Payloads and attributes The payload is the body of the...
This is the heaviest topic on the exam and the one that separates candidates who have built flows from those who have only read about them. Every Mule event has a payload, attributes and variables. You need to know how to access each, how to modify each, and what happens when you do. The exam tests your ability to read DataWeave expressions and processor configurations, then predict the outcome.
β Payloads and attributes
The payload is the body of the message. Attributes are metadata: HTTP headers, query parameters, status codes, file properties. You must know how to reference each in DataWeave, how to transform one into the other, and what happens when a processor changes the payload or the attributes. The exam will show you a DataWeave script or a processor configuration and ask what the payload looks like afterward. Common traps include assuming attributes are part of the payload, forgetting that some processors replace the payload entirely, and writing DataWeave that references a field that does not exist. You also need to know how to extract a single field from the payload, how to merge two payloads, and how to construct a new payload from attributes.
β Variables and targets
Variables store data outside the payload. You set them with the Set Variable processor or with a target parameter on a connector. The exam tests your ability to predict when a variable is in scope, what happens when you overwrite one, and how to reference a variable in DataWeave. The target parameter is a Mule 4 feature that lets you store the output of a connector operation in a variable without replacing the payload. Candidates who learned Mule 3 often assume the payload is always replaced, and they lose marks when a target is used. You need to know the syntax for setting a target, how to access the result, and what happens to the payload when a target is specified. The exam also tests your ability to enrich an event by combining the payload with data from a variable or a connector result.
How Accessing and Modifying Mule Events is tested
Ten percent means around six or seven items. Most show you a flow fragment with processors and DataWeave expressions, then ask what the payload, attributes or variables contain at a specific point. You must trace the event through the flow, applying each transformation in order. The exam catches candidates who skim the DataWeave without running it mentally, who forget that a connector without a target replaces the payload, and who confuse attributes with variables. You will also see questions that ask you to choose the correct DataWeave expression to achieve a stated outcome, such as extracting a field, filtering an array, or merging two objects. The wrong answers are usually syntactically close but semantically incorrect: they reference the wrong part of the event, or they produce a structure that does not match the requirement. This topic demands precision. A single misplaced dot or bracket changes the answer.
Volume matters here. The more items you work through, the faster you recognise the pattern of a payload replacement versus a target, or the shape of a DataWeave expression that accesses attributes. The practice test lets you build that pattern recognition under timed conditions.
The question below gives you a flow fragment and asks you to predict the state of the Mule event after a series of transformations.
A working Mule application is a collection of XML configuration files, property files and resources. This topic tests your ability to organise them correctly, to know when to split a flow into multiple files, when to externalise a property, and how to pass an event between flows and subflows. The weight is the same as the previous topic, and the difficulty is similar. The first sub-topic covers when and how to structure applications into separate files. You need to know...
A working Mule application is a collection of XML configuration files, property files and resources. This topic tests your ability to organise them correctly, to know when to split a flow into multiple files, when to externalise a property, and how to pass an event between flows and subflows. The weight is the same as the previous topic, and the difficulty is similar. The first sub-topic covers when and how to structure applications into separate files. You need to know when to create a global configuration file, when to move properties into a YAML or properties file, and how to reference those properties in your flows. The exam expects you to recognise good separation of concerns: configuration that changes between environments belongs in a properties file, reusable error handlers belong in a global file, and business logic belongs in flows. The second sub-topic is about passing events between flows and subflows. A flow reference passes control to another flow or subflow and waits for it to complete. A connector publishes an event to a queue or topic. You must know when to use each, what happens to the payload and variables, and whether the call is synchronous or asynchronous. Candidates who confuse flow references with VM or JMS connectors lose marks.
How Structuring Mule Applications is tested
Ten percent means around six or seven items. The exam presents a scenario where an application needs to be refactored or extended, then asks you to choose the correct structuring approach. You will see questions about where to place a property, how to reference it, and what happens if the property is missing. You will also see questions that show a flow with a flow reference or a connector, then ask what the payload or variables look like after the call. The exam tests your understanding of scope: variables set in a subflow are visible to the caller, but variables set in a flow called via a VM connector are not. Candidates lose marks by assuming all calls are synchronous, by forgetting that a flow reference blocks until the called flow completes, and by placing environment-specific configuration directly in the flow XML instead of externalising it. The questions are scenario-driven and require you to predict outcomes based on the structure you choose.
The practice test shows you how the exam phrases structuring questions, so you learn to distinguish between items that test property externalisation and those that test flow reference behaviour. The PDF lets you review the scope rules for variables and the syntax for referencing properties.
The question below asks you to predict the outcome when an event is passed between flows using a flow reference.
You have designed the API. Now you implement it. This topic tests your ability to build the flows that sit behind an API specification, either manually or using APIkit. You need to know what APIkit generates, what you must add, and how to implement responses that match the RAML contract. β Manual implementation and APIkit scaffolding The exam expects you to know how to implement an API without APIkit, using HTTP listeners and manual routing. You must also know what...
You have designed the API. Now you implement it. This topic tests your ability to build the flows that sit behind an API specification, either manually or using APIkit. You need to know what APIkit generates, what you must add, and how to implement responses that match the RAML contract.
β Manual implementation and APIkit scaffolding
The exam expects you to know how to implement an API without APIkit, using HTTP listeners and manual routing. You must also know what APIkit does when you scaffold from a RAML file: it generates flows for each resource and method, it creates a router, and it validates incoming requests against the RAML. You need to predict what the generated flows look like and where you add your business logic. Candidates who have only used APIkit lose marks when asked to implement an API manually, and candidates who have only built APIs by hand lose marks when asked to predict APIkit behaviour. The exam tests both.
β Implementing responses that match the specification
A RAML specification defines the structure and status codes of responses. You must implement flows that produce those responses, either by setting the HTTP status explicitly or by letting APIkit handle it. The exam will show you a RAML snippet that defines a 201 response with a location header, then ask you to choose the correct Mule configuration. You need to know how to set response headers, how to set the status code, and what happens if your implementation returns a structure that does not match the RAML. APIkit validates responses in some configurations, and you must know when that validation occurs and what error results when it fails.
How Building API Implementation Interfaces is tested
Seven percent means around four or five items. The exam presents a RAML specification and asks you to choose the correct implementation, or it shows you a Mule flow and asks whether it matches the specification. You will see questions that test your ability to predict what APIkit generates, to identify where business logic belongs in a scaffolded flow, and to implement responses with the correct status code and headers. Candidates lose marks by assuming APIkit implements the entire API, by forgetting to set the HTTP status when implementing manually, and by returning response structures that do not match the RAML schema. The exam also catches people who confuse the main flow with the error flows that APIkit generates. You must know which flow handles which status code.
The practice test gives you exposure to both manual and APIkit-based implementation questions, so you can identify which approach you are weaker on. The PDF lets you compare the two side by side and review the response-handling rules.
The question below tests your ability to predict the result of scaffolding an API implementation using APIkit from a RAML specification.
Connectors integrate Mule with external systems: databases, file servers, FTP, HTTP services and more. This is the third ten per cent topic, and it tests your ability to configure connectors correctly, predict their behaviour, and combine data from multiple sources in the middle of a flow. The sub-topics focus on databases, files and data retrieval. β Databases and files The Database connector executes SQL queries and updates. You need to know how to configure a connection, how to pass parameters...
Connectors integrate Mule with external systems: databases, file servers, FTP, HTTP services and more. This is the third ten percent topic, and it tests your ability to configure connectors correctly, predict their behaviour, and combine data from multiple sources in the middle of a flow. The sub-topics focus on databases, files and data retrieval.
β Databases and files
The Database connector executes SQL queries and updates. You need to know how to configure a connection, how to pass parameters to a query, and what the connector returns. The exam expects you to predict the structure of the result: a database select returns an array of objects, and you must know how to iterate over it or transform it with DataWeave. You also need to know how to handle parameterised queries and what happens when a query returns no rows. The File and FTP connectors read, write, list and delete files. You must know how to configure a path, how to read a file into the payload, and what happens when a file does not exist. The exam tests your ability to choose the correct operation, to predict the payload structure after a read, and to handle errors when a file operation fails.
β Retrieving and combining data mid-flow
The final sub-topic is about enrichment: calling a connector in the middle of a flow to retrieve additional data, then combining it with the existing payload. This is where the target parameter becomes essential. You must know how to use a target to store the connector result in a variable, how to access that variable in DataWeave, and how to merge it with the payload without losing the original data. The exam will show you a flow that calls a database or an HTTP service mid-flow, then ask what the payload and variables contain afterward. Candidates who forget to use a target, or who assume the payload is not replaced, lose marks. You also need to know how to handle cases where the connector returns an array and you must match each element to the corresponding item in the payload.
How Using Connectors is tested
Ten percent means around six or seven items. The exam shows you a connector configuration and asks what happens when it executes: what the payload contains, what variables are set, and what error occurs if the operation fails. You will see questions that test your ability to configure a database query with parameters, to read a file and transform its content, and to combine data from two sources using a target. Candidates lose marks by forgetting that a database select returns an array even when only one row matches, by assuming a file read always succeeds, and by writing DataWeave that references the wrong variable after an enrichment call. The exam also tests your ability to choose the correct connector operation for a stated requirement, such as whether to use a select or an insert, or whether to use File or FTP.
Connector behaviour is best learned through volume. The practice test shows you the range of connector questions, from configuration syntax to outcome prediction, so you can identify which connectors you need to work with more. The timed mode helps you avoid spending too long tracing a complex enrichment flow.
The question below asks you to predict the state of the Mule event after a database query is executed with a target parameter.
When your payload is a collection, you need to process each item individually. This topic tests three approaches: For Each scopes, batch jobs and database listeners. Each has different behaviour, different error handling and different use cases. You must predict what happens to the payload, variables and attributes as records move through the scope. β For Each and batch scopes For Each iterates over a collection and executes the processors inside the scope once per item. The payload inside the...
When your payload is a collection, you need to process each item individually. This topic tests three approaches: For Each scopes, batch jobs and database listeners. Each has different behaviour, different error handling and different use cases. You must predict what happens to the payload, variables and attributes as records move through the scope.
β For Each and batch scopes
For Each iterates over a collection and executes the processors inside the scope once per item. The payload inside the scope is the current item, not the whole collection. After the scope completes, the payload reverts to the original collection. You need to know how to access the counter, how to handle errors inside the loop, and what happens to variables set inside the scope. The exam will show you a For Each with a Set Variable or a connector call inside, then ask what the payload or variables contain after the loop completes. Batch jobs are for high-volume processing, often with external systems. A batch job has phases: input, process records, on complete. You must know what the payload looks like in each phase, how to filter records, and how to aggregate results. The exam tests your ability to predict which records succeed, which fail, and what the final payload contains. Candidates lose marks by assuming the For Each payload persists after the scope, or by confusing batch phase behaviour.
β Database listeners and persisting data
A database listener polls a table for new or updated rows. You need to know how to configure the query, how the listener tracks which rows have been processed, and what the payload contains when new rows arrive. The exam expects you to predict the polling behaviour and the structure of the inbound event. The final sub-topic is about persisting data between flow executions, typically using Object Store. You must know how to store a value, retrieve it in a later execution, and handle cases where the key does not exist. The exam will show you a flow that stores a counter or a timestamp, then ask what value is retrieved on the next execution. Candidates who assume variables persist across executions lose marks. You also need to know the difference between a persistent Object Store and an in-memory one, and what happens when the application restarts.
How Processing Records is tested
Ten percent means six or seven items. Most show you a flow with a For Each, a batch job or a database listener, then ask you to trace the payload and variables through the scope. You will see questions that test whether you understand that the For Each payload is scoped to the current item, that batch jobs process records in parallel, and that variables set inside a For Each are visible after the scope completes. The exam catches candidates who forget that the payload reverts after a For Each, who assume batch jobs process records in order, and who try to use variables to persist data between executions instead of Object Store. You will also see questions about database listener watermarking: which rows are processed on the first poll, which on the second, and what happens if a row is updated between polls. This topic demands precise knowledge of scope boundaries and lifecycle.
The question bank helps you see the difference between For Each outcome questions and batch job outcome questions, so you can focus on whichever scope you are less familiar with. The demo shows you the item style before you commit.
The question that follows asks you to predict the payload and variables after a For Each scope completes.
DataWeave is the transformation language in Mule 4, and this is the topic where most of your marks are won or lost. You need to read DataWeave scripts, predict their output, and choose the correct syntax to achieve a stated transformation. The five sub-topics cover type conversion, core functions, transformation syntax, calling flows from DataWeave, and reusing code in modules. β Types, functions and transformation syntax DataWeave has output types (JSON, XML, CSV, Java) and data types (String, Number, Boolean,...
DataWeave is the transformation language in Mule 4, and this is the topic where most of your marks are won or lost. You need to read DataWeave scripts, predict their output, and choose the correct syntax to achieve a stated transformation. The five sub-topics cover type conversion, core functions, transformation syntax, calling flows from DataWeave, and reusing code in modules.
β Types, functions and transformation syntax
DataWeave has output types (JSON, XML, CSV, Java) and data types (String, Number, Boolean, Array, Object). You must know how to convert between them, what happens when a conversion fails, and how to coerce a string to a number or a date. The exam will show you a DataWeave script with an output directive and ask what format the result takes. You also need to predict the result of core functions: map, filter, reduce, flatten, pluck, groupBy and others. The exam shows you an input payload and a DataWeave script, then asks what the output is. Candidates lose marks by confusing map with flatMap, by forgetting that filter returns an array even if only one item matches, and by misreading the order of arguments in reduce. The third sub-topic is about writing transformations that coerce, format, order and filter data. You need to know how to sort an array, how to format a date, how to filter null values, and how to merge two objects. The exam tests your ability to choose the correct DataWeave expression for a requirement and to predict the outcome when multiple transformations are chained.
β Calling flows and reusing code
DataWeave can call a Mule flow using the Mule::lookup function. You must know the syntax, what the function returns, and what happens to the payload and variables in the calling flow. The exam will show you a DataWeave script that calls a flow, then ask what the output contains. Candidates lose marks by assuming the lookup is synchronous or by forgetting that the called flow's variables are not visible to the caller. The final sub-topic is about reusing DataWeave code. You can define functions and variables at the top of a script, and you can import modules from separate files. You need to know how to define a function, how to call it, how to import a module, and how to reference an imported function. The exam tests your ability to predict the result when a function is called with specific arguments, and to identify which syntax correctly imports and uses a module.
How Transforming Data is tested
Ten percent means six or seven items, and they are typically the hardest on the exam. You will see a DataWeave script with an input payload, and you must choose the correct output from four options. The scripts are short but dense: a single map followed by a filter followed by a pluck. You must trace the transformation step by step. The exam catches candidates who skim the script, who confuse similar functions, and who misread the input structure. You will also see questions that ask you to write the DataWeave expression to achieve a stated outcome, such as converting an array of objects into a single object keyed by ID, or filtering an array to remove null values. The wrong answers are syntactically close: they use the wrong function, or they reference the wrong field, or they produce a structure that is almost correct but has the keys and values swapped. This topic requires precision and practice. You cannot pass without being able to read and write DataWeave fluently.
DataWeave questions benefit most from volume. The more transformations you trace, the faster you spot the pattern of a map versus a pluck, or the outcome of a reduce. The practice test builds that fluency under exam conditions.
The question below gives you a DataWeave script and an input payload, then asks you to predict the output structure.
Routing determines which path an event takes through a flow. This topic tests your ability to configure a Choice router with DataWeave conditions, to scatter-gather messages to multiple targets, and to validate events before processing them. The weight is moderate, but the questions require you to trace logic branches and predict outcomes. β Choice routers and DataWeave conditions The Choice router evaluates conditions in order and routes the event to the first matching path. You need to know how to...
Routing determines which path an event takes through a flow. This topic tests your ability to configure a Choice router with DataWeave conditions, to scatter-gather messages to multiple targets, and to validate events before processing them. The weight is moderate, but the questions require you to trace logic branches and predict outcomes.
β Choice routers and DataWeave conditions
The Choice router evaluates conditions in order and routes the event to the first matching path. You need to know how to write DataWeave conditions, what happens when no condition matches, and how to configure a default route. The exam will show you a Choice router with multiple when clauses, then ask which route the event takes given a specific payload or attribute. Candidates lose marks by assuming all routes execute, by forgetting that conditions are evaluated in order, and by writing conditions that reference fields that do not exist. You also need to know how to combine conditions using and, or and not, and how to test for null or empty values. The exam tests your ability to predict the route and to identify incorrect condition syntax.
β Scatter-gather and validation
Scatter-Gather sends the event to multiple routes in parallel, waits for all to complete, then aggregates the results into a single payload. You must know what the aggregated payload looks like, what happens if one route fails, and how to configure error handling. The exam will show you a Scatter-Gather with two or three routes, then ask what the final payload contains. Candidates lose marks by assuming the routes execute sequentially, or by forgetting that the payload is an object with one key per route. The final sub-topic is validation. You can validate an event using the Validation module, checking that fields are present, that values are within range, or that the payload matches a schema. You need to know what error is raised when validation fails, and how to handle that error. The exam tests your ability to predict the outcome when a validation succeeds or fails, and to choose the correct validation expression for a requirement.
How Routing Events is tested
Eight percent means around five items. Most show you a router configuration and an input event, then ask which route executes or what the output payload contains. You will see questions that test your ability to write DataWeave conditions, to predict Scatter-Gather aggregation, and to identify validation failures. The exam catches candidates who forget that Choice conditions are evaluated in order, who assume Scatter-Gather waits only for the first route to complete, and who write validation expressions that do not match the requirement. You will also see questions that combine routing with transformation: a Choice router where each route applies a different DataWeave script, and you must predict the final payload. The questions are usually straightforward if you trace the logic carefully, but they punish candidates who skim the conditions or misread the payload structure.
Routing questions test your ability to trace branches and predict aggregation. The practice test shows you the range of router configurations, from simple Choice to complex Scatter-Gather, so you can identify which pattern you need to review.
The question below shows you a Choice router with multiple conditions and asks which route an event takes given a specific payload.
Errors happen. This topic tests your ability to handle them correctly using global error handlers, on-error scopes, try scopes and custom error mappings. You need to know which handler executes when an error occurs, what happens to the event, and whether the error propagates or is suppressed. β Global and local error handlers A global error handler applies to all flows unless overridden. You need to know how to define one, what errors it catches, and what happens when no...
Errors happen. This topic tests your ability to handle them correctly using global error handlers, on-error scopes, try scopes and custom error mappings. You need to know which handler executes when an error occurs, what happens to the event, and whether the error propagates or is suppressed.
β Global and local error handlers
A global error handler applies to all flows unless overridden. You need to know how to define one, what errors it catches, and what happens when no handler matches the error type. The exam will show you a global error handler with multiple on-error scopes, then ask which one executes for a given error. The second sub-topic is the difference between on-error-continue and on-error-propagate. On-error-continue suppresses the error and returns a success response. On-error-propagate marks the flow as failed and returns an error response. You must predict which one applies, what the HTTP status code is, and what the payload contains after the handler executes. Candidates lose marks by confusing the two, by assuming on-error-continue still returns a 500 status, and by forgetting that the payload inside the error handler is the error object, not the original payload.
β Combining handlers, try scopes and custom errors
You can combine multiple error handlers in a single flow, and the most specific match wins. You need to know the precedence rules, what happens when both a local and a global handler match, and how to configure a catch-all handler. The exam tests your ability to predict which handler executes when multiple are defined. A try scope wraps a section of a flow and handles errors locally without affecting the rest of the flow. You must know what happens to the payload if the try succeeds, what happens if it fails, and how to access the error inside the try's error handler. The final sub-topic is custom error mapping. You can map an error from a connector to a custom error type, then handle that type in your error handler. The exam will show you a connector with an error mapping, then ask what error type is raised and which handler catches it. Candidates lose marks by forgetting to map the error, or by writing a handler that matches the original error type instead of the custom one.
How Handling Errors is tested
Eight percent means around five items. Most show you a flow with error handlers and a scenario where an error occurs, then ask which handler executes, what the HTTP status is, and what the payload contains. You will see questions that test your ability to distinguish on-error-continue from on-error-propagate, to predict the outcome when multiple handlers are defined, and to trace the payload through a try scope. The exam catches candidates who assume all errors return 500, who forget that on-error-continue suppresses the error, and who write error handlers that match the wrong error type. You will also see questions about custom error mappings: a connector raises an error, you map it to a custom type, and you must predict which handler catches it. This topic requires you to know the error handling lifecycle and the precedence rules.
Error handling questions test your ability to predict which handler executes and what the response looks like. The practice test shows you the range of handler combinations, from simple global handlers to complex try scopes, so you can focus on the pattern you find hardest.
The question below presents a flow with both global and local error handlers, then asks which one executes when a specific error occurs.
When a flow fails, you need to find the root cause. This topic tests your ability to read error messages, interpret logs, and trace the event through a flow to identify where and why it broke. The weight is the lightest on the exam, but the questions are often scenario-based and require you to eliminate wrong answers by understanding the Mule runtime's behaviour. You have one sub-topic: identifying root causes when debugging. That means reading a stack trace, recognising common...
When a flow fails, you need to find the root cause. This topic tests your ability to read error messages, interpret logs, and trace the event through a flow to identify where and why it broke. The weight is the lightest on the exam, but the questions are often scenario-based and require you to eliminate wrong answers by understanding the Mule runtime's behaviour. You have one sub-topic: identifying root causes when debugging. That means reading a stack trace, recognising common error patterns, and predicting what went wrong given a description of the failure. The exam will show you an error message or a log excerpt, then ask you to choose the most likely cause. You need to know what a NullPointerException means in the context of DataWeave, what a connectivity error looks like, what happens when a required property is missing, and what error you see when a transformation fails because the input structure does not match the script. Candidates lose marks by choosing the most obvious answer instead of the most specific one. A transformation error might feel like a DataWeave syntax problem, but the root cause is often a missing field in the payload or an incorrect data type. You also need to know how to use breakpoints in Anypoint Studio, what information the debugger shows you at each step, and how to inspect the payload, attributes and variables mid-flow. The exam does not ask you to describe the Studio interface in detail, but it does expect you to predict what you would see if you paused execution at a specific processor.
How Debugging and Troubleshooting Mule Applications is tested
Five percent means around three items. Most present an error message or a description of unexpected behaviour, then ask you to identify the root cause from four options. The wrong answers are plausible but do not match the error type or the failure point. You will see questions about null pointer errors, connectivity timeouts, transformation failures and missing configuration properties. The exam catches candidates who jump to conclusions without reading the error carefully, who confuse a symptom with a cause, and who assume the error occurs at the last processor in the flow when it actually occurs earlier. You may also see a question that asks what you would inspect in the debugger to diagnose a specific issue, such as checking the payload structure before a transformation or verifying that a variable was set correctly. The questions are usually short, but they require you to think through the failure path rather than pattern-match against memorised error messages.
Debugging questions test your ability to interpret errors and trace execution. The question bank gives you exposure to the range of error messages and failure scenarios, so you learn to recognise the root cause without second-guessing yourself under time pressure.
The question below gives you an error message and asks you to identify the most likely root cause of the failure.
Building the application is half the job. This topic tests your ability to deploy it to CloudHub, manage it using API Manager, and apply policies to control access and behaviour. The three sub-topics are deployment, proxies with auto-discovery, and policy management. β CloudHub deployment CloudHub is MuleSoft's cloud runtime. You need to know how to deploy an application, how to configure environment properties, and what happens when the deployment fails. The exam expects you to predict the outcome when you...
Building the application is half the job. This topic tests your ability to deploy it to CloudHub, manage it using API Manager, and apply policies to control access and behaviour. The three sub-topics are deployment, proxies with auto-discovery, and policy management.
β CloudHub deployment
CloudHub is MuleSoft's cloud runtime. You need to know how to deploy an application, how to configure environment properties, and what happens when the deployment fails. The exam expects you to predict the outcome when you change a property or redeploy with a different worker size. You must also know how to configure a CloudHub-specific setting, such as static IPs or persistent queues. Candidates lose marks by assuming all properties are the same in CloudHub as they are in Studio, or by forgetting that environment-specific configuration must be externalised. The exam will show you a deployment scenario and ask what configuration is required, or what error occurs if a required setting is missing.
β API Manager, proxies and policies
API Manager controls access to your APIs. You can manage an API using auto-discovery, which links your Mule application to an API instance in API Manager, or you can deploy a separate proxy. You need to know when to use each approach, how to configure auto-discovery in your application, and what happens if the API Manager instance does not exist. The exam tests your ability to predict the outcome when auto-discovery is enabled or when a proxy is deployed. The final sub-topic is policies. A policy is a rule applied to an API: rate limiting, client ID enforcement, IP whitelisting. You must know how to apply a policy, what order policies execute in, and what happens when a policy rejects a request. The exam will show you a policy configuration and ask what response the client receives, or it will ask you to choose the correct policy for a stated requirement. Candidates lose marks by confusing the order of policies, by assuming all policies return 403 when they reject a request, and by applying policies that do not match the requirement.
How Deploying and Managing APIs and Integrations is tested
Seven percent means around four or five items. The exam presents a deployment or management scenario and asks you to choose the correct configuration or predict the outcome. You will see questions about CloudHub properties, auto-discovery setup, and policy behaviour. The exam catches candidates who forget to externalise environment-specific configuration, who assume auto-discovery works without configuring the API Manager instance, and who apply policies in the wrong order. You will also see questions that test your ability to choose the correct policy for a requirement, such as rate limiting versus throttling, or client ID enforcement versus IP whitelisting. The questions are usually scenario-driven and require you to understand the deployment and management lifecycle, not just memorise configuration syntax.
Deployment and management questions test your ability to configure CloudHub and API Manager correctly. The practice test helps you see the range of scenarios, from simple property configuration to complex policy interactions, so you can check your coverage across all three sub-topics.
The question below asks you to predict the outcome when an API is deployed with auto-discovery enabled but the corresponding API Manager instance is missing.
Ready to Start Practicing?
Access all questions and start your exam preparation journey
Upgrade to Full Salesforce Certified MuleSoft Developer (Mule-Dev-201) Exam Questions π