Boomi Professional study plan

Map the Boomi process-building toolbox by listing each shape type and writing one sentence on when you would choose it over its nearest alternative

Build a three-shape process that reads a flat file from a local disk, maps it to a second profile, and writes it back out, then run it in Test mode and read every line of the execution log

Explain in writing the difference between a Document shape, a Map shape, and a Business Rules shape, including the data type each one expects on its input

Configure a decision step using a branch on a document property and verify both branches execute by forcing each path once

Construct a process that calls a sub-process and passes parameters into it, then modify the sub-process signature and repair the caller

Handle errors deliberately by adding a try-catch path, a Notify shape, and a retry loop bounded by a counter document property

Schedule the process with a process property override and confirm the override takes effect in a manual run

Compare a low-code process against a custom-scripted step and note where scripting is justified versus where it adds maintenance risk

Define three profiles by hand (flat file, JSON, and XML) and set every field type, key, and optional flag correctly

Design a map with at least two functions, one conditional default, and one lookup, then validate the map and fix every reported warning

Load a small reference data set into a persisted cache and use it inside the map instead of a hard-coded value

Document the difference between a profile's data format settings and its field definitions, and predict what breaks when each is wrong

Write down the key data-management rules you rely on (document flow, cache scope and lifetime, batch versus single-document processing) and flag every rule you cannot state confidently for later review

Build a batch process that splits a large input into documents, processes each one, and collects results into a single outbound document

Test a deduplication or upsert pattern against a small local store and record what happens on a duplicate key

Review your week 3 map and refactor one repeated expression into a reusable user-defined function

Publish a simple process as a REST endpoint with a defined request and response profile, then call it with a local HTTP client

Add authentication to the endpoint and verify an unauthenticated call is rejected with the expected status code

Explain in writing the difference between an API component, an API proxy, and an API gateway policy, and when each is used

Configure one policy (rate limiting or JSON validation) and prove it triggers by sending a deliberately bad request

Sketch the request path from a client through the gateway to the backing process and annotate where authentication, transformation, and throttling occur

Describe what an AI-oriented infrastructure layer must provide (credential handling, model endpoint configuration, request shaping, observability) and map each item to a Boomi component you can name

Configure an outbound connector to an external service using a stored credential rather than an inline secret

List the failure modes you would monitor for an AI-backed integration and state one mitigation for each

Explain in writing what makes a workflow agentic rather than scripted, naming the role of tool selection, intermediate reasoning, and stopping conditions

Design an agent flow that chooses between two tools based on input content and define the guardrail that prevents an unbounded loop

Add a human-approval or confirmation step before an irreversible action and describe how the flow resumes afterward

Identify three risks specific to agentic automation (unexpected tool calls, data leakage into prompts, runaway cost) and write the control you would put on each

Re-read every item you flagged as uncertain across weeks 1 through 7 and resolve each one or mark it as a known gap

Rebuild from memory one integration, one map, and one API endpoint without notes, then compare against your earlier work and list the differences

Write and answer twenty practice questions spread across all five domains in the exam weighting, scoring yourself honestly

Produce a final gap list ranked by domain weight so remaining study time goes to the highest-value weaknesses first