BJSC MCQ cheat sheet

Blue Prism separates process logic (Process Studio) from application logic (Object Studio); a Process calls Actions exposed by Objects.

Core object types: Application Modeler defines applications, Business Objects expose Actions, and Processes orchestrate them in the Control Room.

A Process is published as a Process; an Object is published as a Business Object; only published items are visible to Control Room scheduling.

Stages are the building blocks: Action, Decision, Choice, Calculation, Data, Collection, Loop, Block, Page, Read, Write, Navigate, Wait, Exception.

Data Items hold single values; Collections hold tabular data with defined fields; both are typed (Text, Number, Date, Time, Flag, Binary).

The Control Room executes Sessions from a Process or Object; a Session is one running instance of a published Process or Object.

Blue Prism uses a client-server architecture: interactive clients, runtime resources, and a central database (SQL Server by default).

Environment variables (formerly environment variables in System Manager) store configuration values that differ between runtime environments.

Main Page runs top-to-bottom; use Page stages to modularise and Block stages to scope exceptions and recoverable sections.

Decision stage has one or more outgoing links each with a Boolean expression; Choice stage routes on the value of a single expression against multiple outcomes.

Loop stage iterates over a Collection; the loop's current row is referenced by the Collection's field names inside the loop.

A Block stage traps exceptions raised inside it; the Recover link runs on exception, the Resume link runs on success.

Calculation stage evaluates an expression and stores the result in a Data Item; use it for string concatenation, arithmetic, and function calls.

Link conditions must be Boolean; a Decision with no true outgoing link raises an exception if none evaluates true unless a fallback is designed.

Use Process Studio's Step, Step Out, and Trace to debug; breakpoints pause execution at a stage for inspection.

Naming convention: prefix data items by type (e.g., dte for date, txt for text) and give stages descriptive names for maintainability.

Application Modeler creates an Application element; each Application holds one or more Application Modeller entries for windows/controls.

Spy modes: Win32 for standard Windows controls, Accessibility for some Java/legacy apps, UIAutomation for modern apps, Region for image-based matching, HTML for browser DOM.

Match attributes (Window Text, Class Name, Control ID, etc.) determine element identification; wildcards (*) and dynamic attributes improve robustness.

Use Wait stages with the correct condition (e.g., window exists, element exists) before interacting with an element to avoid timing exceptions.

Actions in a Business Object should be atomic and reusable; each Action should perform one logical interaction and return meaningful outputs.

Attach/Detach: Objects attach to an application at the start of an Action and detach on completion; unattached actions fail.

Read stages extract text/attributes from elements; Write stages set values; Navigate stages click, focus, or send keys.

Use Global Send Keys and Global Send Key Events for keyboard input; prefer element-level writes where the control supports them.

Exception types: System Exception (unrecoverable, terminates the Session) and Business Exception (recoverable, handled by process logic).

Raise an exception with the Exception stage; specify Type (System or Business), Exception Type name, and a descriptive message.

Block stage Recover link catches exceptions from inside the block; use it to clean up, log, and either re-raise or continue.

Preserve the original exception: use the Exception detail (Exception Type and Message) when re-raising so root cause is retained.

Recoverable vs non-recoverable: business exceptions (e.g., item not found) should be handled and the item marked as an exception in the queue.

Always clean up (close apps, release locks, reset state) in the Recover path before re-raising a System Exception.

Log exceptions with the Exception Type and Message; avoid empty or generic messages that hide the root cause.

Use Preserve/Recover patterns: the Recover stage resets the block to the stage after the Block; the Resume stage continues after the block on success.

Work Queues store items with states: New, In Progress, Completed, Exceptioned, and Deferred.

Get Next Item locks an item to the requesting Session; the lock is released on completion, exception, or timeout.

Item keys must be unique; use Add to Queue with a unique key to prevent duplicate processing.

Queue item status transitions: New → In Progress → Completed or Exceptioned; Deferred items return to New after the deferral period.

Control Room manages Sessions, Resources, and Queues; a Resource can run one Session per license (or per configured concurrency).

Schedules define when Sessions start; they reference a Process or Object and a Resource.

Queue priorities and item priorities determine processing order; higher priority items are retrieved first.

Use the Queue's 'Attempts' and 'Defer' settings to retry failed items; set Maximum Attempts to avoid infinite retries.

Environment variables (System Manager) are read at Session start; changes require restarting the Session to take effect.

Follow the ROM (Robotic Operating Model) phases: Process Definition, Solution Design, Solution Configuration, Solution Testing, Solution Deployment, and Post-Implementation.

Use the Process Definition Document (PDD) to capture business process; the Solution Design Document (SDD) translates it into technical design.

Design for reusability: build Business Objects once and reuse them across Processes; keep Actions atomic.

Separate configuration from code: use Environment Variables for environment-specific values (URLs, credentials, file paths).

Apply robust exception handling at every level: Object → Process → Queue; always mark queue items as Exceptioned on unrecoverable failure.

Test at unit (Object), integration (Process), and UAT levels; use test data and verify queue outcomes.

Logging and auditability: log key events and exceptions; use Blue Prism's built-in logging and session logs.

Deployment: publish Objects and Processes, import/export via release packages, and verify environment variables per environment.

Maintainability: consistent naming, modular Pages, documented Actions, and version control of releases.