Salesforce MuleSoft Hyperautomation Developer

Flow sits closest to the data and the users, which makes it the usual hub. You build the right flow type for a scenario, use subflows and fault paths, and keep flows maintainable as they multiply.

• Record-triggered, screen, scheduled and autolaunched flows
• Choosing the right flow for a scenario
• Subflows and reusable building blocks
• Fault paths and error notification
• Flow limits and bulk behavior
• Naming and organizing flows at scale

You build Flows of three types that automate one end-to-end business process.

A bot handles the routine part of a conversation and passes the rest on. You design dialogs and intents, call flows from a bot to act on data, and plan the handoff to a human.

• Where a bot fits in a service process
• Dialogs, intents and entities
• Calling flows from a bot
• Collecting and validating input
• Transferring to a human agent
• Reviewing bot conversations to improve them

You build A bot with several dialogs that calls a flow and hands off to an agent.

Automation that touches live data must be tested and connected carefully. You test record-triggered flows with the flow testing tools, and reach outside Salesforce with HTTP callouts, external services and invocable Apex.

• Flow tests and what they assert
• Test data for record-triggered flows
• HTTP callout actions
• External services from an API specification
• Invocable Apex as a bridge
• Named credentials and securing calls

You build A tested record-triggered flow that calls an external API through a named credential.

Some processes run for days across many people and systems. You combine flows into an orchestration with stages and steps, set entry and exit conditions, assign work to queues and groups, and debug and deploy it.

• When an orchestration is better than one flow
• Stages, steps and background steps
• Entry and exit conditions
• Parallel and multi-user work
• Assigning steps to queues and groups
• Debugging and deploying an orchestration

You build An orchestration that coordinates parallel steps across two teams.

Composer lets non-developers connect systems without code. You build flows from triggers and actions, use connectors, and apply flow controls to branch and repeat.

• What Composer is for and who uses it
• Triggers, actions and connectors
• Connecting systems and authorizing access
• Flow controls: conditions and repetition
• Moving data between Salesforce and other systems
• Composer limits and when to move to Anypoint

You build A Composer flow that moves data between Salesforce and another system.

Data rarely matches between systems. You transform values with formulas, test flows with sample data, read run history, and troubleshoot flows that fail or run too often.

• Formulas for text, number and date values
• Mapping fields between systems
• Testing a flow before activating it
• Reading run history
• Handling errors and retries in flows
• Troubleshooting flows that misbehave

You build A Composer flow with transformations, tests and a documented fix for a failed run.

Robots suit work that has no API. You evaluate which processes are good candidates, learn how RPA Manager, builders and bots fit together, and design a process before recording any steps.

• When RPA is the right answer
• Evaluating a process for automation
• RPA Manager, builder and bots
• Designing steps, inputs and outputs
• Handling exceptions in a design
• Credentials, security and governance for bots

You build A process evaluation and design document for one robotic automation.

A designed process still has to run reliably. You build and test a process, deploy it to bots, schedule and trigger it, monitor runs, and troubleshoot failures.

• Building a process with the builder
• Testing with realistic data
• Deploying to a bot
• Triggering and scheduling runs
• Monitoring runs in RPA Manager
• Troubleshooting a failed run

You build A built and deployed RPA process that is monitored through several runs.

Where an API exists, it beats a robot or a one-off connection. You describe composable APIs and their specifications, survey Anypoint Platform capabilities, and compare the deployment options for Mule applications.

• What makes an API composable
• Specifications for APIs
• Anypoint Platform capabilities in outline
• Deployment options for Mule applications
• Choosing a deployment for a scenario
• Calling an API from Flow and Composer

You build A design that exposes one business capability as a composable API used by Flow.

Reuse needs a place to find things. You publish assets to private and public exchanges, test APIs with the mocking service before they exist, and apply practices that make assets easy to adopt.

• Private and public exchanges
• Publishing APIs, fragments and templates
• Documenting an asset for consumers
• Using the mocking service
• Discovering and reusing existing assets
• Exchange best practices

You build A published asset with documentation and a working mock.

Automation depends on endpoints that stay up. You manage endpoints and proxies, apply policies, and use Anypoint Monitoring to see how the APIs behind your automations perform.

• Managing an API in API Manager
• Endpoint and proxy configuration
• Applying and ordering policies
• Anypoint Monitoring dashboards
• Alerts on the endpoints automations rely on
• Reading metrics to find a problem

You build A managed endpoint with policies and a monitoring dashboard with alerts.

Tools only work well together when they agree on how to talk. You choose communication patterns between Flow, Composer, RPA and Anypoint, plan test data and fault handling in each tool, and design for reuse.

• Communication patterns between the tools
• Triggers, events and callbacks across tools
• Fault handling in each tool
• Modeling tests and test data across tools
• Design patterns for reuse
• Documenting a multi-tool automation

You build A cross-tool pattern guide showing how one process is triggered, run and recovered.

Automate one business process that needs a flow, a Composer integration, an API and a robot. You pick each tool on purpose, connect them, test the whole, and explain where you would change the design.

• Selecting a process and mapping its steps
• Assigning each step to a tool
• Building and connecting the pieces
• Testing, monitoring and fixing faults
• Reviewing the design for reuse and risk

You build A working automated process across Flow, Composer, Anypoint and RPA, documented.