Blue Prism Solution Designer key terms

The design environment where you build and test business processes as flowcharts of stages, decisions, and links. It runs against a simulated or live session and is separate from the object layer.

The design environment used to build reusable business objects that expose actions and interact with a single application. It holds the pages, application modeler settings, and action definitions consumed by processes.

A reusable component that wraps one application or system and publishes actions other designers can call. It hides interface detail behind a stable contract so processes do not depend on screen specifics.

A published entry point on a business object that a process can call, with defined inputs and outputs. Each action typically maps to one page and performs a single business-meaningful operation.

A single flowchart within an object or process that groups related stages. Pages can be called by other pages or actions, which keeps logic modular and testable in isolation.

A single step on a flowchart, such as an action, decision, calculation, read, write, or block. Each stage type carries its own properties and connection rules for links.

The directed connector between stages that defines control flow and can carry conditions. A link's expression determines whether execution follows that path after the preceding stage completes.

A branching stage that evaluates one or more outgoing link conditions and routes execution accordingly. Designers use it instead of complex nested conditions to keep flow readable and auditable.

A multi-way branching stage that selects exactly one outgoing link based on a single expression or index. It is clearer than chained decisions when several mutually exclusive paths exist.

A named variable that holds a value during a process or object run, with a declared data type and optional initial value. Scope determines whether it is visible to one page or the whole component.

The declared kind of value a data item can hold, such as text, number, date, time, flag, or binary. Types constrain valid operations and conversions during execution and validation.

A structured data item holding rows and named fields, similar to a table. Collections are the standard way to pass lists of work items or query results between pages and objects.

A stage that repeats a block of logic over a collection or until a condition ends. It removes the need to duplicate stages and is essential for processing queues of records.

A grouping stage that contains nested stages and runs them as a unit, optionally repeating. Blocks improve readability and let designers scope recovery and cleanup around a set of steps.

The design pattern of anticipating failures, blocking or recovering around risky stages, and routing control to cleanup or escalation paths. It prevents a single error from aborting an entire run.

A stage that defines a recovery path attached to a block, so that a failure inside the block transfers control to recovery logic instead of terminating. It is central to resilient process design.

A design pattern that attempts a fragile interaction a limited number of times with a delay or reset between attempts. It must include an exit condition to avoid endless loops.

The tool used inside Object Studio to identify and map application elements, such as buttons, fields, and windows, so actions can interact with them reliably. It stores the element definitions and match attributes.

A named reference to a control in a target application, such as a text box or menu item, created through the modeler. Actions read from and write to these elements rather than raw screen coordinates.

The set of properties, such as name, class, or position, used to locate an element at run time. Choosing stable attributes is the main defense against brittle automation after application changes.

A technique of using pattern characters in match attributes so an element is found even when part of its label changes. It trades precision for resilience when values are dynamic.

A capture mode in the modeler that highlights and records the attributes of a control under the cursor. Designers compare spy results to choose the most stable identifying attributes.

A value passed into an action or page when it is called, declared with a name and data type. Inputs define the contract callers rely on and should be validated inside the action.

A value returned by an action or page to its caller, declared with a name and data type. Outputs carry results, status flags, and messages back to the calling process.

A centralized store of work items that processes retrieve, process, and mark complete or exceptional. It enables load balancing, retry, prioritization, and reporting across multiple runtime resources.

A single record in a work queue holding the data and state needed for one unit of work. Items carry status, priority, tags, and attempt counts that drive processing decisions.

The lifecycle state of a work item, such as new, in progress, completed, or exceptioned. Status transitions drive retry behavior and reporting on throughput and failure rates.

A work item deliberately postponed until a later time or condition, for example when a dependent system is unavailable. Deferral keeps the item in the queue without consuming attempts.

The operational console where administrators deploy processes, start and stop sessions, manage queues, and review logs. It is the boundary between design-time artifacts and production operation.

A running instance of a process on a runtime resource, which can be started manually or by a schedule. Sessions report status, logs, and exceptions to the control room.

A machine or environment registered to execute sessions, with its own configuration and capacity. Work is distributed across resources to scale throughput and isolate failures.

A configured rule that starts a process or session at defined times or intervals, optionally with parameters. Schedules support unattended operation and predictable batch windows.

A packaged, versioned snapshot of processes, objects, and related components that is imported into an environment. Releases make deployments repeatable and support rollback to a prior version.

The controlled movement of a release through environments such as development, test, and production. It includes configuration checks, smoke tests, and sign-off before go-live.

The practice of tracking changes to process and object artifacts with versions, comments, and history. It supports comparison, rollback, and audit of who changed what and why.

The recorded history of a session's execution, including stage activity, errors, and custom messages. Logs are the primary evidence for troubleshooting and operational reporting.

The role or forum that approves design standards, reusable components, and significant design decisions. It prevents divergent patterns and enforces naming, error handling, and reuse conventions.

A static check that flags structural problems such as unlinked stages, missing data, or unreachable paths before a process runs. It catches defects early but does not prove business correctness.

A shared object or page built once and consumed by many processes, such as a logging or queue helper. Reuse reduces duplication and keeps behavior consistent across the solution.

The retained record of changes and runtime events that supports compliance review and root-cause analysis. It should capture who did what, when, and the resulting outcome.