Blue Prism Pro Developer study plan

Draft a page-by-page process design for a three-stage workflow, labeling each stage as process, object, or page, and justify every boundary in writing.

Diagram a solution architecture with separate presentation, process, object, and data layers, then annotate where work queue items and credentials live.

Define at least ten naming conventions for pages, stages, data items, and collections, and apply them to the draft design.

Build a skeleton process in Process Studio with the designed stage names, empty subpages, and typed input and output data items.

Explain in writing why business logic belongs in process layers rather than object layers, citing two failure scenarios.

Implement decision stages that branch on collection counts, string comparisons, and flag values, then verify each branch with a test run.

Construct a loop stage that iterates a collection and writes a formatted result row into a second collection.

Use a collection to hold at least five rows with mixed field types, and filter it into two subsets using a decision and loop combination.

Create reusable subpages for logging and data validation, and call each from two different parent pages.

Trace one full run step by step and record the value of every data item at each stage transition.

Spy a local test web application using each available spy mode and record which mode suits text fields, buttons, and tables.

Build an object with an application model, an attach action, a launch action, and at least three business actions.

Parameterize every selector with wildcards or dynamic attributes so the object survives a page reload and a changed row index.

Create a second object that calls a public REST API using the HTTP request capability, and parse the JSON response into a collection.

Document a Citrix or surface-automation fallback approach for one screen that cannot be spied conventionally.

Classify five failure types as business exceptions or system exceptions and justify each classification in writing.

Implement a recover-and-resume block around a fragile object call, with a retry limit and a clean-up page.

Design a work queue schema with key fields, priority, tags, and a deferred status for items that must wait.

Configure an exception handling pattern that marks an item as an exception after the retry limit and records the reason.

Write a recovery procedure describing what happens to in-flight items when a process is stopped mid-run.

Build a scheduler entry with a trigger, a time window, and a resource constraint, then simulate a missed run.

Configure multiple resources against one queue and verify that items are not double-processed.

Add a control-room dashboard view that surfaces queue depth, exception rate, and average handling time.

Refactor the demo process to read its configuration, such as retry limits and file paths, from a central config source rather than hard-coded values.

Run a load test with fifty queue items and record throughput and any contention issues.

Map five roles to least-privilege permissions and document what each role can and cannot do.

Draft a credential-handling policy covering storage, retrieval, rotation, and access logging.

Design an environment promotion path from development to test to production, listing what is exported and what is reconfigured at each step.

Write a release checklist with at least eight pre-deployment verification items.

Identify three audit artifacts a governance review would request and describe how to produce each.

Assemble a full end-to-end solution combining process layer, objects, queue, exception handling, and configuration.

Conduct a design review against a checklist covering layer separation, selector robustness, and exception coverage, and log findings.

Remediate at least three findings from the review and record the before and after for each.

Write an operations runbook covering start, stop, recovery, and escalation for the assembled solution.

Verify that no credentials or environment-specific values appear in exported release content.

Complete two timed practice sets weighted to the domain percentages and score each by domain.

Re-study the two weakest domains using targeted notes and rebuild one artifact for each.

Recite from memory the decision rules for exception classification, queue retry behavior, and layer boundaries.

Walk through one unfamiliar scenario aloud and design a solution in under fifteen minutes.

Consolidate a one-page cheat sheet of selector strategies, queue states, and role permissions.