Boomi process properties vs global variables is not a cosmetic naming decision. It determines whether a production change is controlled in one process, governed centrally for an environment, or accidentally mixed into the data travelling through an integration. The same canvas can contain all three scopes, but they should never be used interchangeably.
My working model is intentionally strict. Dynamic Document Properties (DDPs) carry facts about one document. Process Property components hold controlled, process-local constants. Global Variables hold centrally governed environment configuration. With that separation, an operator can answer three different questions without tracing hidden state: “which customer failed?”, “what is this process designed to do?”, and “which endpoint or credential applies in Production?”
This is a practical application of the Correlation Identifier pattern. Business-message context must remain with the message. Configuration must remain outside the message. The remaining decision is whether configuration belongs to this one process or to the environment shared by many processes.
Boomi process properties vs global variables: the short answer
Use a Dynamic Document Property for a per-document fact: DDP_ORDER_ID, DDP_CORRELATION_ID, source filename, routing decision, document retry count or failure category.
Use a Process Property component for a controlled constant that describes this process’s behaviour: PP_MAX_RETRY_ATTEMPTS, PP_AUDIT_ENABLED, PP_MINIMUM_BATCH_SIZE or a process-specific business rule. Treat it as a declared process contract, not as a mutable bag of runtime data.
Use a Global Variable for a value that is genuinely environment-specific and must be managed centrally across supported components and multiple processes: an API base URL, tenant identifier, connection setting, or a non-OAuth secret in a supported encrypted field.
The useful question is not “can Boomi store this value here?” All three mechanisms can appear convenient. Ask instead: does the value belong to one document, to the design of one process, or to the environment that runs many processes?
DDP_CORRELATION_ID = A9Travels with one message through maps, branches and connectors.PP_MAX_RETRY_ATTEMPTS = 3Controlled behaviour for this process and its deliberate subprocess contract.$V{ERP_API_BASE_URL}One centrally managed value, assigned for Test or Production where supported.Scope is an ownership boundary. The wider the scope, the less suitable it is for record-level state.
The decision table: document, process, or environment?
| Value | Correct home | Why | Example |
|---|---|---|---|
| Business key, source filename, route, trace ID | Dynamic Document Property | It describes one message and must survive transformations and recovery. | DDP_ORDER_ID |
| Process-local retry limit, validation policy, audit switch | Process Property component | It is a controlled constant for this process’s behaviour, visible in its design. | PP_MAX_RETRY_ATTEMPTS = 3 |
| Production versus Test endpoint, tenant, shared connection setting | Global Variable | It is environment configuration that should be assigned and governed centrally. | $V{ERP_API_BASE_URL} |
| Shared account-wide non-OAuth secret in a supported encrypted field | Global Variable | Rotation and access control belong to the platform configuration boundary. | $V{ERP_API_KEY} |
| State that must survive executions or coordinate documents | Database, queue, cache, or other durable service | Neither property mechanism is a transactional, shared state store. | Idempotency record |
Why use Process Properties at all?
Global Variables are not a replacement for Process Property components. They solve a different configuration problem. A Process Property component gives a process an explicit, reusable set of name/value settings. Those values sit with the integration design, can be used in parameters, maps and scripts, and make the process’s operational behaviour legible to the next developer.
That makes Process Properties the right place for constants with a process owner. Consider a process that may call a supplier API three times, waits 30 seconds between attempts, and writes an audit event only for specific business flows. Those are process decisions. Put them in a component with deliberate names and defaults:
PP_MAX_RETRY_ATTEMPTS = 3PP_RETRY_DELAY_SECONDS = 30PP_AUDIT_ENABLED = truePP_ACCEPTED_SCHEMA_VERSION = 4
The point is control, not convenience. The values are reviewable with the process, part of its deployment contract, and can be changed deliberately through the component or an approved process extension. They should normally be stable for an execution. Boomi confirms that a Process Property value lasts for the whole process run and is available to deliberate parent/child process designs. That is useful for controlled process behaviour; it is the wrong shape for facts that differ per document.
Do not default to setting a Process Property from the payload. A value copied from Order A into a Process Property is no longer an order fact; it has become execution state. That design appears harmless in a one-document test and becomes ambiguous when a batch, a Branch or Flow Control is introduced. Boomi documents that Process Property values set in concurrent Flow Control threads are not available to the other concurrent threads. Keep record-level information in DDPs instead.
Process extensions do not invalidate this model
A Process Property component can be exposed as an extension, so Boomi can defer a value until deployment. This is valuable when the setting belongs to one process but deployment needs approved control. For example, a regulatory retention period may be a process-owned rule that needs a different approved value in a sandbox.
But an extension configured independently for every process becomes expensive when the same real environment value is repeated across dozens of integrations. When the endpoint, tenant, certificate setting or secret belongs to the environment rather than the process, move it to a Global Variable instead. The decision is about ownership and reuse, not merely whether a value can technically be overridden.
When Global Variables are the better answer
Global Variables provide central configuration management for values that apply across an account and can be assigned per environment. They can be referenced in supported component text and encrypted-text fields. This makes them a stronger fit than repeated Process Property extensions when one platform team needs to control the Test, Acceptance and Production values used by many processes.
Typical candidates are:
$V{ERP_API_BASE_URL}for the environment-specific base URL used by several integrations;$V{SALESFORCE_TENANT}for a centrally governed tenant or organisation value;$V{MFT_SFTP_HOST}for a shared host setting;$V{PARTNER_SHARED_SECRET}for a non-OAuth secret in a supported encrypted field.
This creates a clean operational model. Integration developers reference the approved variable. The platform or environment owner assigns its value. A Production endpoint change then has one visible change point rather than a hunt through individual process extensions. Boomi’s privileges also support this separation: defining a Global Variable, assigning an environment value and viewing values can be granted separately.
Global Variables are still configuration—not a runtime API. They do not carry a correlation ID, coordinate retries for individual documents, or hold a record of which invoice was sent. They are also not a universal replacement for every Boomi field: use them only where the target component supports them.
Operational limits to include in the runbook
- After a Global Variable value changes, any listener that uses it must be restarted manually.
- An Operation Import is not compatible with an associated Connection that uses a Global Variable; temporarily use a literal value for the import, then restore the variable reference.
- Global Variables are not supported for OAuth-encrypted values.
- A central value has central blast radius. Define an owner, change window, rollback value and validation step before changing Production.
Dynamic Document Properties remain the message-context default
The Process Property versus Global Variable choice only starts after you establish that a value is configuration. If the value identifies, routes, observes or recovers one document, it belongs to a Dynamic Document Property.
For an inbound batch of customer updates, set DDP_CUSTOMER_ID, DDP_SOURCE_SYSTEM and DDP_CORRELATION_ID immediately after the source connector. If one document fails after a map or outbound API call, the error handler can report the exact business record without parsing a transformed payload or guessing which shared slot was most recently written.
DDPs follow a document through transformations and outbound connector calls, which is why they are the natural implementation of a Correlation Identifier. They are strings held in memory during use, so keep them concise. Do not put large payloads, access tokens or durable business state in them.
Example: invoice delivery with clear ownership
Imagine one Boomi process that reads invoices from an ERP, validates them, delivers them to a customer platform and records an audit event. It runs in Test and Production and shares its target platform with several other integrations.
- At the source, set
DDP_INVOICE_ID,DDP_SOURCE_SYSTEMandDDP_CORRELATION_ID. These facts must stay with each invoice. - Use a Process Property component for
PP_MAX_RETRY_ATTEMPTS = 3,PP_RETRY_DELAY_SECONDS = 30andPP_AUDIT_ENABLED = true. These values describe how this invoice process behaves and can be reviewed with its design. - Reference
$V{CUSTOMER_PLATFORM_BASE_URL}and the supported environment credentials in the Connection or Operation fields. The Test and Production values are assigned centrally, rather than copied into every process. - On failure, produce an alert using the DDP business key and correlation ID. The alert reports the failing invoice; it does not expose a Global Variable or rely on a mutable Process Property.
- When a Global Variable changes, validate one safe transaction and restart any affected listeners as part of the same release runbook.
The result is straightforward to operate. The integration developer owns the retry and audit policy. The platform owner owns the environment endpoint and credential configuration. The operations team can trace an individual invoice. No scope is pretending to solve another scope’s problem.
Implementation checklist
- Classify each value before adding it: message fact, process constant, environment configuration or durable state.
- Use
DDP_names for document context and set business keys close to the inbound connector. - Keep Process Property components small, named and process-owned. Prefer declared defaults over values dynamically set from incoming documents.
- Use
PP_names for process constants such as retry policies and process-specific switches. - Use Global Variables for values that must differ by environment and be reused centrally in supported component fields.
- Give every Global Variable an owner, description, environment values, change procedure and rollback value.
- Test batches, a mid-batch error, branches and Flow Control before approving a Process Property design.
- Do not use Process Properties or Global Variables as an idempotency store, cross-document database or message-correlation mechanism.
- For a Global Variable change, include listener restarts and the documented Import Operation and OAuth restrictions in the release checklist.
FAQ
Why not use Global Variables for every configurable value?
Because central configuration is not automatically better configuration. A retry policy or validation rule that belongs to one process should remain visible with that process. Moving it to an account-wide setting hides ownership and increases blast radius. Use a Global Variable when the value is truly an environment concern shared by multiple supported components or processes.
Can Process Properties be environment-specific?
Yes. Boomi supports Process Property extensions, which can defer a value until deployment. Use this when the value still belongs to one process and an approved deployment override is appropriate. Prefer a Global Variable when the same environment value is duplicated across many processes and needs one central owner.
Can I set a Process Property during a process run?
Technically, yes. Boomi supports setting and retrieving Process Properties during a run. Architecturally, use that capability narrowly for controlled execution orchestration. Do not use it for document-specific state: values set in concurrent Flow Control threads do not provide a safe shared hand-off. Use DDPs for the current document and durable services for shared state.
Where should a correlation ID go?
In a Dynamic Document Property such as DDP_CORRELATION_ID. It identifies one message and must remain correct through maps, branches, retries and outbound calls. It is neither a process constant nor environment configuration.
Build the scope model before the canvas grows
Reliable Boomi integrations make the scope of every value obvious. Keep the message with its context. Keep process behaviour in controlled Process Property components. Keep environment configuration in centrally governed Global Variables. This small architectural rule reduces faulty recovery, configuration drift and production-change risk long before the flow becomes complex.
For a related operational perspective, see how enhanced listener reporting improves Boomi runtime visibility.





0 Comments