Job Role



In-Person: 5 Full Day(s)
Virtual: 5 Full Day(s) or 10 Half Day(s)


Who should take this course?

This course is for solution and technical architects or lead/senior developers that are focused on designing enterprise integration solutions and have prior experience developing and deploying non-trivial Mule applications. It prepares you to take the MuleSoft Certified Integration Architect - Level 1 exam and includes two exam attempts.




Experience developing and deploying Mule applications as demonstrated by one of the following: 



Additional development and architecture knowledge and experience including:


  • Proficiency in any JVM-based programming language with ability to read procedural, object-oriented, and (ideally) functional code
  • Familiarity with threads, thread pools, locks, server/client sockets, JDBC data sources, and connection pools on the JVM
  • Proficiency with current software development tools like Git/GitHub, Maven, Jenkins, or similar
  • Experience as an architect or lead/senior developer on at least one integration project using any technology stack
  • A full understanding of the fundamental ingredients of enterprise integration including interface definitions and contracts; data encoding using XML or JSON; REST APIs or SOAP web services; SQL or NoSQL database access; message-passing using JMS, AMQP or similar; network protocols like TCP/IP, HTTP and HTTPS; single-resource transactions
  • Familiarity with basic security concepts including certificates and encryption at rest and in transit

When you complete this course, you will be able to:

  • Translate functional and non-functional requirements into well documented integration interfaces and implementation designs.
  • Select the best Mule components and patterns for integration solution designs.
  • Select the deployment approach and configuration of Anypoint Platform with any of the available deployment options (MuleSoft-hosted or customer-hosted control plane and runtime plane).
  • Design Mule applications for the various deployment options of the Anypoint Platform runtime plane.
  • Apply standard development methods covering the full development lifecycle to ensure solution quality.
  • Design reusable assets, components, standards, frameworks, and processes to support and facilitate API and integration projects.
  • Design and be responsible for the technical quality, governance (ensuring compliance), and operationalization of integration solutions.
  • Advise technical teams on performance, scalability, reliability, monitoring, and other operational concerns of integration solutions on Anypoint Platform.


Setup Requirements


  • A computer with:
    • At least 8-16 GB RAM (16 highly recommended) available RAM, 2GHz CPU, and 10GB available storage
    • A minimum screen resolution of 1024x768
  • Internet access to ports 80 and 3306 (with > 5Mbps download and > 2Mbps upload)
  • The latest version of Chrome, Safari, Firefox, or Edge
  • Anypoint Studio 7.14 with embedded Mule 4.X runtime
  • An Anypoint Platform account
  • Advanced REST Client (or any other REST client application)
  • (Optional) ArchiMate (or some other architecture diagramming tool)

Class Registration

Lessons and Topics

PART 1: Architecting and designing integration solutions


Introducing integration solution architectures

  • Describe the objectives of enterprise integration solution
  • Summarize how to architect for customer success with MuleSoft
  • Describe how integration solutions are documented
  • Describe key parts of an architecture template for integration solutions


Identifying Anypoint Platform components and capabilities

  • Identify overall design intentions of Anypoint Platform
  • Review Anypoint Platform capabilities and high-level components
  • Review API-led development techniques and options
  • Identify Anypoint Platform components used to design and govern web APIs
  • Explain event-driven API support in Anypoint Platform
  • Distinguish between Anypoint Platform service and deployment models


Designing integration solutions using Mule applications

  • Identify how Mule application components are typically used to implement integration solutions
  • Apply Mule application components and capabilities to a range of use case
  • Summarize how class loading isolation is implemented in Mule runtimes


Choosing appropriate Mule event processing models

  • Distinguish between Mule blocking, non-blocking, parallel, and reactive event processing options
  • Identify the event processing models used in various Mule scopes and components
  • Identify Mule streaming options and behaviors
  • Describe the fundamentals of web APIs and event-driven architecture
  • Describe the event processing options for JMS and VM connectors
  • Select appropriate event processing for an integration use case
  • Design integration use cases with batch, near real-time, and real-time data synchronization


Choosing appropriate message transformation and routing patterns

  • Describe reusable ways to transform and process events
  • Explain how to simplify and decouple complex data mappings using common data models
  • Design transformations between data models
  • Choose the best event transformation, data validation, and event routing patterns to an integration use case


Designing Mule application testing strategies

  • Explain why testing is important in an integration project
  • Identify the MuleSoft-provided framework and tools for testing during the software development lifecycle
  • Design testing strategies for a Mule application
  • Define test coverage for flows in a Mule applications


PART 2: Operationalizing integration solutions


Choosing and developing a deployment strategy

  • Identify the service and deployment models supported by Anypoint Platform
  • Distinguish between various Anypoint Platform deployment models
  • Design containerized deployments for Mule runtimes
  • Decide deployment options for various scenarios


Designing with appropriate state preservation and management options

  • Decide the best way to store Mule application state in persistent or non-persistent storage
  • Identify how to store a CloudHub application state using Object Store v2
  • Decide when to manage storage of Mule application state using persistent queues
  • Configure Mule application provided caches to store Mule application state
  • Avoid duplicate processing of previous records using watermarks and idempotency validation


Designing effective logging and monitoring

  • Describe auditing and logging options for Mule applications
  • Design logging strategies for Mule applications
  • Choose logging policies for Mule application log files
  • Describe integration options with third-party log management systems
  • Specify Anypoint Platform monitoring, alerting, notification, visualization, and reporting options for APIs and integration solutions


Designing an efficient and automated software development lifecycle

  • Manage property files for Mule applications across different environments
  • Manage Anypoint Platform environments for Mule application deployments
  • Implement continuous integration and continuous delivery (CI/CD) for an organization
  • Automate deployment and management with Anypoint Platform


PART 3: Strategies to meet non-functional requirements


Designing transaction management in Mule applications

  • Identify why and when transactions are supported in Mule applications
  • Identify resources that participate in transactions in Mule applications
  • Demarcate transaction boundaries in Mule applications
  • Choose the transaction type based on the participating resources
  • Manage a transaction using the Sage pattern


Designing for reliability goals

  • Distinguish between competing non-functional requirements
  • Clarify and validate reliability goals for a scenario
  • Design Mule applications and their deployments to meet reliability goals
  • Identify reliability pattern for Mule applications


Designing for high availability goals

  • Clarify high availability (HA) goals for Mule applications
  • Balance HA goals with reliability and performance goals
  • Identify ways to achieve HA using Anypoint Platform in CloudHub and customer-hosted runtime planes
  • Identify HA aware connectors and their design tradeoffs


Optimizing the performance of deployed Mule applications

  • Clarify performance goals for Mule applications
  • Balance performance goals with reliability and HA goals
  • Identify the need for performance optimization and associated tradeoffs
  • Describe ways to search for and locate performance bottlenecks
  • Describe how to design, architect, and implement for performance
  • Describe ways to measure performance
  • Describe methods and best practices to performance tune Mule applications and Mule runtimes


Designing secure Mule applications and deployments

  • Identify Anypoint Platform security concepts and options
  • Describe how to secure APIs on Anypoint Platform
  • Explain the security needs addressed by Anypoint Platform edge security
  • Differentiate between MuleSoft and customer responsibilities related to Anypoint Platform security
  • Evaluate security risks for Mule applications
  • Describe how to secure Mule application properties and data in transit


Designing secure network communications between Mule applications

  • Describe Anypoint Platform network security options and architectures
  • Describe how to secure Mule applications using Java key stores
  • Design TLS communication and other network security options for an integration use case
  • Distinguish between various CloudHub deployments with load balancers
  • Properly size an Anypoint Virtual Private Cloud (VPC) to support deployment of all expected Mule applications