Salesforce MuleSoft Developer

A good API is designed before it is built. You use HTTP verbs and resources correctly, define parameters and responses, and tell query parameters from URI parameters in a specification.

• Resources and HTTP verbs
• URI parameters and query parameters
• Request and response bodies
• Types, examples and status codes
• Writing RAML in Design Center
• Mocking a specification

You build A RAML specification for a small API, tested with its mocking service.

Every processor in a flow works on the same event. You build flows in Studio, read and change the payload, attributes and variables, and use the debugger to see what an event holds at each step.

• Studio, projects and running an application
• Flows, sources and processors
• The Mule event: payload, attributes and variables
• Set Payload, Set Variable and Transform
• Enriching an event with a target
• Predicting an event after a processor

You build A flow that reads a request and shapes the event with variables and a transform.

Applications grow messy unless they are organized. You split work into configuration files, externalize properties for each environment, and pass events between flows and subflows.

• Splitting configuration into several files
• Properties files and environments
• Flow references and subflows
• Private flows against public flows
• Naming and structure conventions
• Passing events between flows

You build A restructured application with properties files and reusable subflows.

APIkit turns a specification into a working interface. You scaffold flows from RAML, predict how the router sends requests, and return the right status codes and bodies.

• Scaffolding from a RAML specification
• How the APIkit router matches requests
• Implementing resource flows
• Returning responses and status codes
• Handling errors with APIkit mappings
• Testing with the console

You build An API implementation scaffolded from a RAML spec, answering correctly in the console.

Connectors link flows to real systems. You use database, file and FTP connectors with the right operations, set up configurations, and combine data from several sources in the middle of a flow.

• Connector configurations and global elements
• Database select, insert and update
• Reading and writing files
• FTP and SFTP operations
• Combining data from two sources
• Handling connection failures

You build A flow that reads a file, queries a database and combines the results.

Collections need different handling from single messages. You loop with For Each, process large sets with batch scopes, react to rows with database listeners, and persist data between runs.

• For Each and what it changes in the event
• Batch jobs, steps and aggregators
• Batch error handling
• Database listeners and watermarks
• Persisting data across executions
• Choosing For Each or batch

You build A batch job that processes records from a database and keeps track of progress.

DataWeave is the language of every transformation. You write scripts with headers, bodies and operators, convert between formats and types, and predict what a script returns for a given input.

• Script structure: header and body
• Output formats and MIME types
• Selectors and navigating data
• map, filter and mapObject
• Type coercion and formatting
• Predicting a script’s output

You build Transformations that convert between JSON, XML and CSV, each with a predicted output.

Repeated logic belongs in one place. You define variables and functions, group them into modules, import them across scripts, and use core functions such as groupBy and orderBy.

• Variables and functions in the header
• Lambdas and function parameters
• Defining and importing modules
• groupBy, orderBy and pluck
• Default values and null handling
• Reusing a module across applications

You build A DataWeave module of functions used by two different transformations.

Flows decide where each event goes. You route with choice routers, run work in parallel with scatter-gather, and validate events before they reach processing.

• Choice router conditions
• Scatter-Gather and its results
• Combining results from routes
• The validation module
• Validating payload and attributes
• Predicting which route runs

You build A flow that validates a request and routes it to different processing paths.

Failure handling is part of the design. You use global and local error handlers, tell on-error continue from propagate, wrap risky steps in try scopes, and map errors to custom types.

• Error types and the error object
• On-error continue and on-error propagate
• Global default error handlers
• Try scope for local handling
• Custom error mappings
• Predicting the result of an error path

You build An application with global and local handlers that return clear error responses.

When a flow gives the wrong answer, you need a method rather than guesses. You use the debugger, logs and event inspection to find the root cause of errors and to predict outcomes before running.

• Breakpoints and the Studio debugger
• Watching payload, attributes and variables
• Logger and log levels
• Reading stack traces and error descriptions
• Isolating a fault by simplifying the flow
• Common root causes and their signs

You build A troubleshooting record for three faulty flows, each traced to its cause.

A working flow still has to run somewhere. You deploy to CloudHub, place proxies and auto-discovery to connect applications to API Manager, and apply policies to control access.

• Deploying an application to CloudHub
• Runtime Manager settings and properties
• Managing an API in API Manager
• Proxies and auto-discovery
• Applying policies
• Checking logs and status after deployment

You build An application deployed to CloudHub, governed by an API Manager policy.

Build one API from end to end: the specification, an implementation with connectors and DataWeave, error handling and deployment. You test it and explain each step you took.

• Designing the API specification
• Implementing flows and transformations
• Adding connectors, routing and error handling
• Debugging and deploying
• Reviewing the finished API

You build A deployed API with a spec, connectors, DataWeave and error handling.