📘 Session 1 – Learning Objectives & Topics Covered Link to

1. Understand the Exam as a Product, Not Just a Project

• Learn how MuleSoft frames APIs as products, emphasizing long-term value and design thinking.

2. Build Exam Mindset & Strategy

• Decode tricky or ambiguous exam questions.

• Learn to focus on how the question is written, not just what you know.

• Understand how to analyze and eliminate distractors in multiple-choice scenarios.

3. Learn in Layers: Depth Over Memorization

• Embrace a layered learning approach, focusing on how MuleSoft works under the hood—not just how to use it.

• Discover why real understanding beats superficial memorization in certification success.

4. Challenge-Based Learning

• Use failed attempts as learning tools—write down confusing questions and map them to objectives.

• Translate objectives into presentations or PoC-style demos to master the topic.

• Reinforce that teaching back is a great way to retain knowledge.

5. MuleSoft Curriculum Focus

• Understand that your current focus should be on Anypoint Studio, not Code Builder.

• Stay aligned with the MCD1 curriculum and tools used in the official training.

6. Terminology & Core Concepts

• Clarify key API-led connectivity concepts, product vs. project mindset, and layered API design.

• Prep for discussions around network layers, contract-first design, and integration use cases.

🧠 Additional Topics Covered in the Recording 1. C4E (Center for Enablement) Philosophy

• Emphasis on empowering teams to carry best practices beyond the classroom.

• Encourages a discipleship model—spreading knowledge across teams and roles.

2. Future-Proofing Through API-Led Design

• Why teams should deeply understand why they design APIs a certain way.

• Reinforces specification quality, data types, and error handling as critical for scalable integrations.

3. Architectural Influence

• Learners are encouraged to take ownership of best practices when returning to their dev, architect, or stakeholder teams.

4. Metrics & KPIs

• Mentions tools and methods for tracking adoption of API-led principles.

• Highlights the importance of reusability (e.g., tracking fragment reuse) as a measure of architectural maturity.

  Summary Document:

  https://docs.google.com/document/d/1QEVKkVUqt2DHhCAL3F4j9-RWZhGcpR-bwfiKLUzXnLI/edit?tab=t.0#heading=h.nj9w1earmgek

📘 Session 2 – Learning Objectives & Topics Covered Link to

1. Explore the API Lifecycle

• Understand the full lifecycle of an API—from discovery to publishing.

• Learn when and why to create a new specification using RAML or OAS (OpenAPI/Swagger).

2. Design Fundamentals

• Dive into the role of API Designer and Anypoint Code Builder in spec creation.

• Compare different specification languages and where they fit in modern integration.

3. Specification-Driven Development

• Learn how API specs act as contracts between teams.

• Discover best practices for building reusable, well-documented interfaces.

4. Anypoint Exchange and Reuse

• Discover how to find and evaluate APIs and assets in Anypoint Exchange.

• Learn how publishing and reusing fragments accelerates development.

5. Design First vs. Code First Approaches

• Discuss the benefits and tradeoffs of each method.

• Align the design-first strategy with MCD1 expectations.

  https://docs.google.com/document/d/1nYXYpO2EdmvQIWfX1XcF6eTHRUNnBJvEfu1mGgdZa9U/edit?tab=t.0#heading=h.b1a8sdm9gksl

📘 Session 3 – Learning Objectives & Topics Covered Link to

1. API Deployment & Management Overview

• Learn where the API lifecycle continues after design and testing.

• Understand the transition from development to deployment environments.

2. Runtime Options in MuleSoft

• Compare CloudHub, Runtime Fabric, and Hybrid deployments.

• Understand when to use each deployment type based on business needs.

3. Deploying Mule Applications

• Explore best practices for packaging, deploying, and promoting Mule applications.

• Understand deployment artifacts, configuration files, and automation strategies.

4. API Auto-Discovery

• Learn how to use the Auto-Discovery feature to link APIs to API Manager.

• Understand the role of api.id and secure gateway configuration.

5. Managing APIs in Anypoint Platform

• Navigate API Manager to apply policies, analytics, and SLA tiers.

• Explore how to control versions and apply updates post-deployment.

6. Monitoring & Troubleshooting

• Introduce key monitoring tools within the Anypoint Platform.

• Learn how to view logs, handle alerts, and ensure uptime.

  Summary Document: https://docs.google.com/document/d/1JRMBhJxHFV4tGW8b9wiHRo10Abq70gZSIMyJmhEKno4/edit?tab=t.0#heading=h.tys6np99t07k

📘 What You’ll Learn in Session Four Link to

1) The purpose and power of DataWeave, MuleSoft’s core transformation language

• When and how to use key DataWeave functions: map, filter, reduce, groupBy, orderBy, ++, and default

• The structure of a DataWeave script (header, delimiter, body) and how to avoid common syntax errors

• How to identify and handle data types (arrays, objects, strings, numbers, nulls) to prevent transformation errors

• Real-world and exam-style transformation examples, including:

• Concatenating name fields

• Mapping arrays of objects

• Filtering for active entries

• Reducing values for totals

• Grouping and sorting by fields

• Default values for missing data

• Joining related data using map + filter

• How to write and read lambda expressions in map, filter, and reduce

• Why function order matters (groupBy vs. orderBy) and how structure affects logic

• How to format output for both humans and systems, including dates and fallback values

2) The complete breakdown of Batch Jobs in MuleSoft:

• What they are, why they matter, and how they work

• Configuration of batch scopes, block sizes, concurrency, and scheduling

• Using acceptExpression and acceptPolicy to control record flow

• When and how to use Batch Aggregators for grouped processing

• What happens in the On Complete phase—and what doesn’t

• Understanding variable scope across batch steps and flow

• Practice flows showing real MuleSoft logger behavior at each stage

  Summary Document:

  https://docs.google.com/document/d/1rHgI77-bB2whyqp1NDZwGYvq-U7bkU9QbemZZj7n1wM/edit?tab=t.0#heading=h.tys6np99t07k

• Raise Error, On Error Propagate, and On Error Continue – Learn how to purposefully throw and catch errors using MuleSoft’s error handling scopes

• Flow-Level vs. Global Error Handlers – Understand where to place error handlers and how their scope affects flow behavior

• System Errors vs. Messaging Errors – Know which types of errors you can handle inside flows and which ones require external strategies

• Mule Error Object – Use error.description and error.errorType to inspect, log, and route errors accurately

• HTTP Listener Default vs. Custom Behavior – Discover what status codes and responses are returned by default and how to override them using vars.httpStatus

• APIkit’s Auto-Generated Error Handling – See how APIkit creates flows and handlers from RAML, and how it uses variables to manage responses

• Comparing On Error Continue and On Error Propagate – Master the difference in flow behavior, response codes, and processor execution

• Mule Default Error Handler – Recognize when this fallback kicks in and how it mimics On Error Propagate behavior

• Handler Type Matching & Stacking – Learn to define multiple error scopes and why their order (specific to general) determines which one is triggered

• Parent vs. Child Flow Error Handling – Explore how errors propagate or are absorbed across flow references and what payload wins in the response

• Sub Flows vs. Private Flows – Understand which can have their own error handling and which inherit from the caller

• Processor-Level Try Scope – Isolate errors at the processor level for granular control without affecting the entire flow

• Global Error Handlers – Configure and apply app-wide error handling when no local scope catches the error

• Error Mapping – Replace verbose error types with meaningful custom identifiers for cleaner error handling

• Mule Error Logic Flow – Follow Mule’s built-in decision tree to determine which handler will run and why

• HTTP Status Overrides – Use variables to change response codes (like from 500 to 400) even inside On Error Propagate scopes

• Exam Tips with Scenario Practice – Apply everything you've learned to real-world style exam questions with status codes, payloads, and error scope behavior

  Summary Document:

  https://docs.google.com/document/d/1V88KvyOfS2IvOy0A0wQ5COkY-9vOHq4dKBK8DvrIQo4/edit?tab=t.0#heading=h.tys6np99t07k

• API Governance Fundamentals – How governance profiles, rule sets, and OWASP integration help enforce API design-time standards in Anypoint Platform

• Using Rule Sets – Applying built-in and custom rule sets (e.g., OWASP, Required Examples) to APIs using governance profiles

• Conformance Monitoring – How MuleSoft tracks conformance, shows violations, and blocks noncompliant assets from being published to Exchange

• Automated Alerts & Remediation – How alerts, violation reports, and team collaboration support continuous improvement

• Routing Processors Deep Dive – Choice, Scatter-Gather, First Successful, and Round Robin routers—how they differ and when to use each

• Validation Module in Action – Using validation processors like isEmpty, isNull, isEmail, etc., to ensure clean data before flow execution

• Semantic Versioning (SemVer) – How MAJOR.MINOR.PATCH versioning works in Exchange and what changes require each type

• Versioning Scenarios & Best Practices – Understanding how different API updates (e.g., adding a required field vs. fixing a typo) impact version numbers

• Exam Prep Strategy & Time Management – Real tips for pacing, flagging questions, and using WebAssessor to schedule and pass your exam

• Test Day Setup – What to expect from the proctoring environment, system checks, and exam-day do’s and don’ts

  Summary Document:

  https://docs.google.com/document/d/1J1PfRA_VdgmLshEItCK3rK0FWtmUuUZzH6A3RiP9anU/edit?tab=t.0#heading=h.tys6np99t07k