Salesforce MuleSoft Platform Integration Architect

A Mule application behaves according to how the runtime schedules work. You learn the Mule 4 reactive event model, its thread pools, and how class loader isolation separates applications and their dependencies.

• The Mule 4 event and message model
• Non-blocking processing and the reactive model
• CPU light, CPU intensive and blocking I/O pools
• Tuning scheduling for a workload
• Class loader isolation and dependency conflicts
• Diagnosing a stuck or slow flow from thread behavior

You build A runtime analysis of one flow that explains its threading and dependency behavior.

Where applications run determines what they can share and survive. You analyze Mule runtime clusters, CloudHub networking and shared domains, and choose the topology that suits a set of applications.

• Runtime clusters and what they share
• Primary node behavior and clustered schedulers
• CloudHub networking and VPC options
• Shared domains and shared resources
• Load balancing across workers
• Choosing a topology for a set of applications

You build A topology design for a set of applications with its sharing and networking rules.

One business need can be met with an API call, an event or a message. You compare API-led connectivity, event-driven designs and message brokers, and choose between them with their consequences in view.

• API-led connectivity in an integration architecture
• Event-driven architecture and delivery semantics
• Message brokers and queues
• Publish-subscribe and point-to-point messaging
• Combining paradigms in one solution
• Choosing a paradigm for a requirement

You build A high-level architecture that solves one requirement three ways and recommends one.

Design inside the application decides how it ages. You choose properties and configuration, routers and connectors, design around a canonical data model, and validate data at the right point.

• Properties, secure properties and environments
• Flows, subflows and flow references
• Choosing among routers
• Selecting and configuring connectors, including Salesforce
• Canonical data models: benefits and costs
• Transforming between models with DataWeave
• Validating data at the edge
• Error handling design in a Mule application

You build A Mule application design using a canonical model, routers and validation.

Integrations fail in the joins, so tests must cover them. You design MUnit unit suites with mocks, and decide which scenarios call for integration or performance testing.

• Structuring an MUnit suite
• Mocking connectors and processors
• Testing error paths and routing
• Integration tests against real endpoints
• Performance tests and what they measure
• Test data and environments for integration tests

You build A test plan with MUnit coverage targets and integration and performance scenarios.

State has to survive a restart, and each option differs in how. You design with VM queues, Object Store and stateful components across every deployment option, and know what each loses when a node fails.

• Why Mule applications need state
• VM queues and their durability
• Object Store: scopes, TTL and sharing
• Stateful components and clustering
• Persistence in CloudHub and in other deployment options
• Choosing a persistence mechanism

You build A persistence design for one flow, with behavior described across node failure.

Reliability means deciding what happens on failure before it occurs. You select transaction types, retry and redelivery strategies, and separate high availability from disaster recovery in a design.

• Single-resource and XA transactions
• Retry policies and reconnection strategies
• Redelivery and poison messages
• Idempotency in message processing
• High availability and disaster recovery distinguished
• Designing recovery objectives into a solution

You build A reliability design with transaction, retry and redelivery choices for one critical flow.

Performance targets drive sizing. You design for capacity and throughput goals, use streaming and batching to process large sequences of messages, and keep large payloads from exhausting memory.

• Capacity, throughput and latency goals
• Sizing workers and runtimes
• Streaming strategies and their limits
• Large payloads and memory behavior
• Batch processing for large sequences
• Measuring and tuning an integration

You build A capacity and performance plan for an integration that handles large files.

Security applies at the platform, at the edge and inside the code. You design secure access to the control plane and APIs, secure edge access with Anypoint Security, and counter common vulnerabilities in Mule applications.

• Securing access to the control plane
• Securing APIs and their clients
• Edge security and network access
• Transport security and certificates
• Common vulnerabilities in integration code
• Audit logging and traceability

You build A layered security design for an integration, from platform access to application code.

Operating an integration depends on automation and visibility. You design CI and CD pipelines with the Mule Maven plugin, automate platform actions, and plan logging and monitoring for live applications.

• Pipeline stages for Mule applications
• The Mule Maven plugin in practice
• Automating platform actions
• Promoting across environments
• Logging design and log aggregation
• Monitoring and alerting for live applications

You build A CI and CD pipeline definition for a Mule application with logging and alerts.

Take a requirement set and produce the architecture across platform, runtime, design, persistence, reliability, performance, security and operations. You defend the choices with the trade-offs you accepted.

• Reading the requirement set
• Choosing platform and runtime
• Designing for state, failure and load
• Planning security and operations
• Presenting and defending the solution

You build A full integration solution architecture for one requirement set, with its trade-offs.