The Short Answer
The Salesforce Certified MuleSoft Developer II exam has 60 multiple-choice questions plus up to five unscored, a 120-minute time limit, a 70% passing score, a US$200 registration fee (US$100 to retake) and one hard requirement: you must already hold the Salesforce Certified MuleSoft Developer certification. Questions align to the Spring '24 release (checked in November 2026 against the official exam guide).
Developer II focuses on production-ready flows: built by Maven, tested in a pipeline, observable, resilient under failure and secured end to end. In the official outline, performance and reliability (27%) and maintainable, modular builds (25%) together make up over half the exam.
Exam Details at a Glance
Every fact in this table comes from the MuleSoft Developer II exam guide, except level and languages, which come from the Trailhead Academy exam page.
| Detail | MuleSoft Developer II |
|---|---|
| Questions | 60 multiple-choice, plus up to 5 unscored |
| Time limit | 120 minutes |
| Passing score | 70% |
| Registration fee | US$200 (JPY 30,000), plus applicable taxes |
| Retake fee | US$100 (JPY 15,000), plus applicable taxes |
| Prerequisite | Salesforce Certified MuleSoft Developer |
| Release alignment | Spring '24 |
| Delivery | Proctored, online or at a testing center |
| References allowed | None |
| Level | Advanced |
| Languages | English, Japanese, French, Spanish |
| Maintenance | A maintenance badge on Trailhead once a year |
A note on the passing score. Salesforce publishes 70%; it doesn't publish a fixed number of questions you can miss. Seventy percent of 60 scored questions works out to 42, but treat that as arithmetic, not an official cutoff, and don't plan your preparation around "I can afford to miss 18." The unscored questions are mixed in at random and, per the guide, have no impact on your result, so answer every question as if it counts.
One more detail worth flagging: the guide's maintenance paragraph names the "Salesforce Certified MuleSoft Developer certification maintenance badge" rather than a Developer II badge. Check your own Trailhead profile for the exact badge and due date once you're certified.
Who This Exam Is For
The guide describes the candidate as someone with experience working independently on production-ready Mule applications in a DevOps environment, with typical job roles of Developer and Architect. The Trailhead credential page lists Salesforce Certified MuleSoft Developer under "Earn your Prerequisites", so you can't skip straight to this exam.
That prerequisite shapes what the exam assumes. It won't re-teach DataWeave basics, flow structure or how a Listener works. It assumes you know them and asks what you'd change before go-live. If you passed the first exam recently, our MuleSoft Developer certification guide covers the foundation this one builds on.
You're probably ready to start preparing if you've:
- Shipped at least one Mule application through a CI/CD pipeline rather than deploying from your IDE.
- Debugged a production issue using logs and correlation IDs, not a breakpoint.
- Configured TLS, a keystore or a client-credential flow yourself.
If none of those sound familiar, spend time on real project work first. The guide itself says Salesforce "highly recommends a combination of on-the-job experience and self-study."
The Five Exam Sections, by Weight
The exam outline has five sections covering 29 objectives.
| Section | Weight |
|---|---|
| Implement performant and reliable Mule applications | 27% |
| Implement maintainable and modular Mule applications and their Maven builds | 25% |
| Secure data at rest and in transit | 20% |
| Implement monitorable Mule applications | 15% |
| Expose production-ready Anypoint Platform-managed APIs from Mule applications | 13% |
Performance and reliability (27%)
The heaviest section is about failure. Objectives cover ObjectStore persistence across deployment options, message passing with the VM and Anypoint MQ connectors, fault-tolerant HTTP calls that react correctly to status codes, the Validation module, XML and JSON Schema validation, scatter-gather, and both client-side caching and compensating transactions.
Scatter-gather is a good example of the depth expected. The Scatter-Gather Router documentation explains that routes run in parallel, and that if any route fails, the component throws a MULE:COMPOSITE_ROUTING error carrying both the failed routes' errors and the successful routes' events. Knowing that is what makes "compensating transactions for partially failed scatter-gather" a solvable design problem rather than a guess.
Maintainable and modular builds (25%)
This is a build-engineering section. Expect Maven: modularizing and optimizing build configurations, Maven-based automated deployment to Mule runtimes, and running MUnit tests with Maven. The MUnit Maven Plugin page shows the plugin and dependency setup you should be able to read in a pom.xml. The section also includes building custom API policies, packaging shared logic in libraries, and writing custom message processors with the Mule SDK or XML SDK.
Security (20%)
Five objectives: secure, environment-dependent properties; creating, packaging and distributing keys and certificates; exposing and invoking APIs over HTTPS; TLS mutual authentication on both client and server; and Basic Auth or OAuth2 invocations through HTTP or REST connectors. The TLS configuration page is the core reference. Be clear on the difference between a keystore (your private key and certificate) and a truststore (the certificates you trust), because mutual TLS needs both on each side.
Monitoring (15%)
Health Check endpoints, effective logging, changing log levels and aggregating logs, monitoring with Anypoint Platform or external tools, and correlation IDs persisted and propagated over HTTP. The objectives are about operating an application, so practice by tracing one request across several applications rather than only reading about logging.
Production-ready APIs (13%)
The smallest section covers API artifact versioning, out-of-the-box and custom API policies, server-side caching through policies, HTTP callbacks (webhooks) and API auto-discovery. Auto-discovery is the link between a deployed implementation and its API Manager instance, so make sure you know what breaks when it's misconfigured.
What's Changed Since Spring '24
The exam aligns to Spring '24, and the platform has moved since then. The one change most likely to confuse you while studying: the current API gateway documentation calls the Envoy-based gateway Omni Gateway (formerly Flex Gateway). The same page says a Mule Gateway policy can't be reused in Omni Gateway, or the reverse, because their architectures differ. Mule Gateway custom policies are built much like a Mule application, while Omni Gateway custom policies use Rust WASM SDKs.
The exam objective "Build custom API policies" sits in the Maven-and-modularity section, alongside Mule SDK and XML SDK work, so study the Mule Gateway route described in the Custom Policies overview: develop, package, upload to Exchange, then apply through API Manager. When current docs and an older objective use different names, learn both and expect the exam to use its Spring '24 wording.
A Practical Preparation Plan
Most of this exam can't be learned from reading alone. Here's a plan that follows the weights.
- Build one reference project. Create a small multi-module Maven project with a shared library, a parent POM, MUnit tests run by Maven and automated deployment. That one project covers most of the 25% section.
- Break it on purpose. Add a scatter-gather and make one route fail. Call a flaky HTTP endpoint and handle 4xx and 5xx differently. Pass messages through VM queues and persist state in an Object Store. Watch what each failure does.
- Secure it end to end. Generate a keystore and truststore, enable HTTPS on the Listener, then configure mutual TLS between two applications. Add an OAuth2 client-credentials call.
- Make it observable. Add a health endpoint and structured logging, then propagate a correlation ID across two apps and find one request in the logs.
- Put it behind API Manager. Configure auto-discovery, apply an out-of-the-box policy, then package and apply a simple custom policy.
- Consider the recommended courses. The guide names Anypoint Platform Development: Production-Ready Development Practices (DEX660) and Anypoint Platform Development: Production-Ready Integrations (DEX670) through Trailhead Academy.
Leave the final week for timed practice and for re-reading the docs pages behind whatever you missed. Two hours for 60 questions is about two minutes each, which is generous until you hit a long configuration snippet.
MuleSoft Developer II Practice on Certifyforce
The MuleSoft Developer II practice exam page collects the exam facts and section weights above in one place, and the free MuleSoft Developer II questions are where you can try sample scenarios with explanations before you commit to a study plan.
The full MuleSoft Developer II question pack is Coming soon. It isn't available to buy yet, so check the pricing page for its status rather than relying on a date here.
Frequently Asked Questions
Do I need the MuleSoft Developer certification first?
Yes. The exam guide lists Salesforce Certified MuleSoft Developer as a required prerequisite, and the Trailhead credential page shows it under "Earn your Prerequisites."
How many questions can I miss and still pass?
The exam guide publishes a 70% passing score for 60 scored questions. It doesn't publish an exact number of questions you can miss, so aim well above the line rather than counting on a specific margin.
Is MuleSoft Developer II harder than MuleSoft Developer?
It's rated Advanced on Trailhead Academy. The Developer II guide emphasizes production builds, resilience, security and monitoring, with an audience experienced in independent DevOps work. Use those objectives to identify the hands-on practice you need beyond your existing certification.
How much does the exam cost?
US$200 to register and US$100 to retake, plus applicable taxes, per the exam guide. Japanese yen prices are JPY 30,000 and JPY 15,000.
Which section should I study first?
Start with performance and reliability (27%) and Maven builds (25%), using the published weights. Together they make up over half the exam, and the reference project above covers both.