Quiz ASD01: Blue Prism Designing Blue Prism Process Solutions

The correct answers are B, C, and D.
Here is why:
B. The process should not be designed to use a Blue Prism Work Queue but use Paytex as the work queue.
Correct.
A Blue Prism Work Queue is being used to store payment cases, but the business already has a source system, Paytex, which appears to act as the system of record for cases and their statuses. In general, if the source application already provides the ability to manage, track, and control work, the automation should ideally read from that system rather than duplicating the queue in Blue Prism. Blue Prism queues are best used to manage processing state inside the automation, not as a replacement for an operational case-management system when that source system already exists and is intended to be used by humans and automation together.
C. The process will not scale i.e. you cannot run multiple instances at the same time
Correct.
This is because the queue key is defined as {region} & {source account number}, and only 1 attempt per case is allowed. More importantly, the design implies potential contention around the same business data in Paytex. If multiple process instances are running concurrently and pulling from a queue that is not properly designed to support parallel access, there can be issues with duplicate selection, locking, or inconsistent processing. In exam terms, the design is considered not scalable for concurrent instances.
D. The solution exposes sensitive personal information
Correct.
The payment processing appears to involve customer information, including source account numbers and possibly other personal or financial data. Storing these values in a Blue Prism Work Queue can expose sensitive personal information if the data is not appropriately protected. Blue Prism queues should only contain the minimum necessary data, and sensitive data should be handled carefully, ideally using secure references rather than storing it directly where possible.
Why the other options are not correct:
A. There is a risk that a payment can be duplicated.
Not selected.
Although duplication is always a general concern in automation, the question is pointing to a more specific architectural issue. Since the queue has a single attempt per case and a defined key, the stronger concerns in this scenario are about the design choice of queue usage, scalability, and data sensitivity, rather than duplication being the primary identified flaw.
E. The process should not be automated as it uses a third party web application.
Not selected.
Using a third-party web application does not mean the process cannot be automated. Blue Prism is specifically designed to automate work across web applications, provided the application is technically accessible and stable enough for automation.
F. There is a risk that a payment can be orphaned.
Not selected.
An orphaned payment would mean a case is left unprocessed with no clear ownership or recovery path. In this design, exceptions are set to Manual Review in Paytex, which suggests there is a defined handoff to human operators. Therefore, orphaning is not the primary issue being tested here.
Summary:
The key problems in the proposed solution are:
- It uses Blue Prism Work Queue instead of the business system’s own queue/process control mechanism.
- It is not well designed for concurrent scaling.
- It risks exposing sensitive customer or payment data.
Therefore, the correct answers are B, C, and D.

The correct answers are B and D.
Here is why each option is correct or incorrect.
Context of the design
The process is:
1. Read account IDs from a SQL database
2. For each account ID, read data from PCBS
3. Pass the data to Cred+
4. Mark the record as completed in SQL
The design also says:
- Work queues are encrypted
- One robot account must not have access to both PCBS and Cred+
That means the solution is likely split into separate processes and/or credentials so that one robot only works with one system.
Option B
The solution enables multiple instances of the Get PCBS Data and Update Cred+ processes to run without risk of collision.
Correct.
Why:
- Blue Prism work queues are designed to support multi-bot processing safely.
- Multiple process instances can pick different queue items, and the queue mechanism prevents two robots from processing the same item at the same time.
- Since the data transfer is driven by queue items, more than one bot can run the same process without collision, assuming the design uses queues correctly.
Option D
To reduce the elapsed time of the end to end process, the Get Cases process should be run across multiple machines.
Correct.
Why:
- Running across multiple machines allows parallel processing.
- Since the workload is likely a queue-driven batch of account IDs, distributing the work across several runtime resources would reduce total completion time.
- This is a common scaling approach in Blue Prism to improve throughput.
Why the other options are incorrect
Option A
If the PCBS application suffers an outage, all Blue Prism processes specified in this design must stop processing immediately.
Incorrect.
Why:
- If PCBS is unavailable, only the part of the process that depends on PCBS may need to pause or retry.
- Other processes, such as those updating Cred+ or SQL, might still continue for items already in progress.
- An outage in one application does not automatically mean every Blue Prism process must stop immediately.
Option C
There is a risk that the outcome of a data transfer will not be recorded in the SQL database.
Incorrect.
Why:
- The design explicitly says that once data has been successfully input into Cred+, the SQL record is updated to indicate completion.
- While failures are always possible in any system, this statement implies the design itself necessarily has a recording risk. Based on the proposed architecture, the process is intended to update SQL after successful transfer.
- The question is about the design, and nothing here indicates that recording the outcome is inherently unreliable.
Option E
The process Get PCBS Data should be stopped if the Cred+ application suffers an outage to prevent a backlog of cases in the PCBS Data work queue.
Incorrect.
Why:
- A backlog in a queue is not usually a reason to stop a process; queues are specifically meant to absorb workload.
- If Cred+ is down, the better approach is often to let the queue hold items, or pause only the dependent stage, rather than stopping data extraction entirely.
- The queue backlog is not harmful by itself if the solution is designed to handle it.
Option F
Such sensitive data should not be stored in a Blue Prism work queue
Incorrect.
Why:
- Blue Prism work queues can be encrypted, and the question states that all work queues will be encrypted.
- Sensitive data can be stored in queues if appropriate security controls are in place.
- Therefore, it is not correct to say it should not be stored there at all.
Final answer:
B and D
If you want, I can also explain why the proposed design likely separates the process into two robots/accounts and how that affects the queue architecture.

The correct answers are C and D.
Here is why:
C. There should be a separate work queue for each channel feeding the process.
This is correct because the requirement says requests will arrive from multiple channels using either web services or other Blue Prism processes. In Blue Prism, separate channels often justify separate queues when you need to manage intake, prioritization, monitoring, or retry behavior independently. Even though the question describes four work queues in the solution, this statement aligns with a sensible design choice for multiple inbound channels. It helps segregate volumes and makes it easier to control how different sources are handled.
D. The Confirm Closure process should work until 22:00.
This is correct because the Functional Requirement Questionnaire states that cases must be processed on the same day if they come in between 08:00 and 22:00 Monday to Friday. Since the Confirm Closure step completes the sequence and final closure is only confirmed after the deferred next-day step, the process must be able to keep operating up to 22:00 to meet the same-day processing window requirement.
Why the other options are not correct:
A. All processes should be merged into one process to optimize licenses.
This is not necessarily correct. Merging processes may reduce license usage in some situations, but here the design uses multiple processes for a reason: different stages, deferred timing, and queue-based separation. Optimizing licenses is not enough justification to merge them.
B. Exception cases should not be distributed whilst the processes are running and instead should be distributed when each process has completed.
This is incorrect because the requirement explicitly says exception cases are to be emailed to the manual team during processing as and when they occur. That means exceptions should be handled immediately, not deferred until the process ends.
E. As an alternative the solution could use just one queue instead of four.
This is not correct given the design and requirements. The solution uses multiple queues to separate the stages of processing and manage deferred work. Using just one queue would make it harder to control the workflow, timing, and processing sequence.
Summary:
The correct choices are C and D because the solution must support multiple channels cleanly and the Confirm Closure step must run until 22:00 to satisfy the same-day processing requirement.

The correct answers are A, B, and F.
Here is why each of those is a concern, and why the other options are not the best answers.
A. The solution is not scalable.
This is a valid concern.
The process must handle about 10,000 cases per day, each taking around 30 seconds. Even with up to 10 robots available, the design needs to support growth and volume spikes while still meeting the 4-hour SLA. If the solution relies heavily on manual starting and stopping, and there is no clear mechanism to scale processing efficiently, then it is not well designed for future volume increases or operational demand.
In Blue Prism terms, scalability means the solution can handle increasing workload without major redesign. This scenario raises concern because the throughput and operational approach may not scale cleanly.
B. The process does not have an end stage.
This is a valid concern.
In Blue Prism, a well-structured process should normally include proper termination logic. An end stage is important for clean completion, predictable control flow, and maintainability. If the process lacks an end stage, it may indicate poor design, making it harder to understand, support, and troubleshoot.
Even if the process is intended to run continuously, individual transactions should still end correctly. Missing an end stage can be a sign that the process is not built to accepted design standards.
F. There is no scheduler.
This is a valid concern.
The question says there is to be no scheduler, and instead Process Controllers will manually stop and start process instances based on queue volumes. That is operationally risky. A scheduler is normally used to ensure processes run reliably, consistently, and at the right times, especially in a 24-hour support environment.
Without a scheduler:
- starting and stopping depends on human intervention
- response time may vary
- the process may not begin or stop when needed
- SLA compliance becomes harder to guarantee
- operational resilience is reduced
This is clearly something a solution designer should be concerned about.
Why the other options are not correct
C. The rules engine has been built in a process not an object.
This is not necessarily a concern.
A rules engine in Blue Prism can be built as a process if it is purely logic-based and does not interact with target systems. Since the question states that it does not interact with any target system and only consumes data to apply decisions, building it as a process is acceptable in this context.
D. The process opens and closes the HotRisk system for each case.
This may be inefficient, but the question does not explicitly say this is what is happening, and it is not one of the main design concerns being tested here. Also, depending on the implementation, opening and closing per case might be acceptable if required by the system or session handling pattern. It is not the strongest answer.
E. The data is too sensitive for automated processing.
This is not correct.
Sensitive data does not automatically rule out automation. In fact, automation is often used specifically because it can improve control, reduce human exposure, and provide better auditability when handling sensitive information. The important question is whether the solution has appropriate security controls, not whether automation should be avoided altogether.
Summary
The concerns are:
- A. The solution is not scalable
- B. The process does not have an end stage
- F. There is no scheduler
If you want, I can also explain this from a Blue Prism solution design best-practice perspective, point by point.

The correct answers are B and E.
Here’s why each option is correct or incorrect:
A. The Add Note action in the "BankHost - Notepad" business object does not require an input for Type as the process definition document states that "Information" will always be selected for this process.
Incorrect.
Even if the process definition says that a certain value is always used, the object design still should generally support flexibility and reusability. Hardcoding or assuming a value is always fixed inside the object can reduce maintainability and make future changes harder. Also, the statement is too specific and does not describe a design principle shown by the object design.
B. The object design facilitates a scalable design that will reduce the impact of change when the object layer needs altering
Correct.
This is one of the main benefits of a well-designed object layer in Blue Prism. By separating actions into logically grouped objects, changes to one part of the application are less likely to affect unrelated automations. That makes the design more scalable and easier to maintain over time.
C. The object design should be simplified by storing all BankHost actions in the same object
Incorrect.
This would go against good object-oriented design principles in Blue Prism. Combining all actions into one large object would make the design harder to maintain, harder to test, and more fragile when changes occur. Separate objects should be used when they represent different logical areas or application components.
D. There is no need for attach actions to be replicated across all the objects
Incorrect.
Attach actions are typically needed in each relevant object that interacts with the application, especially if those objects need to establish a session or connect to the application independently. Whether they are replicated depends on the design, but the blanket statement that there is "no need" is not generally correct.
E. The design complies with Blue Prism design best practice.
Correct.
The design follows Blue Prism best practices by organizing the object layer in a modular and maintainable way. Properly separated objects, clear responsibility boundaries, and reduced coupling are all consistent with best-practice design principles.
Summary:
Correct answers: B and E
If you want, I can also explain how to recognize Blue Prism best-practice object design patterns in exam questions.

The correct answer is A.
Why A is the best choice
A. Once in production the process controller should ensure that the process is only ever run on one Resource PC
This is the key design consideration for protecting data integrity and overall process quality.
The scenario describes a morning process that reads a single input file and updates another application. Because the file is usually small, there is no real need to parallelize it across multiple Resource PCs. More importantly, when multiple robots or machines are reading and updating from the same source data, there is a risk of:
- duplicate processing
- skipped records
- inconsistent updates
- file locking or race conditions
- conflicts when multiple resources try to work the same input
By ensuring that only one Resource PC runs the process, the solution avoids concurrency issues and keeps the end-to-end processing predictable and reliable.
Why the other options are not the best
B. The solution should log in to the applications before starting the case working loop
This may be a sensible implementation detail, but it is not the most important quality safeguard for this design. It does not address the main risk, which is multiple resources trying to process the same file.
C. The solution should split the file into pieces to distribute to each Resource PC.
This adds complexity and is unnecessary for a file that is usually small. It also increases the chance of coordination problems and data consistency issues. It is not the preferred approach here.
D. The solution should log out from applications after exiting working loop.
This is good housekeeping, but not a key design choice for guaranteeing solution quality.
E. Each Resource PC should be set to take a different row from the others
This is a parallel processing approach, but for this scenario it is risky because all machines would still be working from the same file. It introduces more complexity and requires very careful coordination to avoid duplicate or missed rows.
F. The solution should start by loading the file data into a work queue.
A queue can be useful in some automation designs, but the question describes a file-based process and asks about guaranteeing quality of the end-to-end solution. A queue is not necessary here and would be an architectural change rather than the most direct safeguard.
G. The file should be updated at the start of each case to prevent other RPCs from working it.
This is not a safe approach. Updating shared files to manage concurrency can create locking and synchronization problems, especially if the update happens before processing is complete.
H. Once in production the clinic should wait until the solution has completed before admitting patients
This is not practical and not a software/process design solution. The business should not have to change operations like this just because of the automation.
I. The batch run should create multiple input files so that each Resource PC has its own file to work with
This might work in a different design, but it is unnecessary here and complicates the upstream batch process. The question’s context suggests a single file input process, so this is not the best answer.
J. The file should be updated after each case to indicate that the case has been worked.
This can help with restartability in some designs, but it is not as robust as ensuring only one resource processes the file. It also still does not solve all concurrency concerns if multiple resources can access the file.
K. The solution should use an environment lock to ensure the file can only be accessed by one Resource PC at a time.
This sounds helpful, but the question asks for options to guarantee the quality of the end-to-end solution. An environment lock is a technical control, but the more direct and appropriate design choice in this context is to control the process so it only runs on one Resource PC in the first place. That is why A is the best answer.
Summary
The most important principle here is to avoid multiple resources processing the same file at the same time. The simplest and most reliable way to guarantee quality is to keep the process on a single Resource PC.
Answer: A

The correct answers are A, C, and D.
Here is the reasoning.
The key issue in the question is that the application can become sluggish, unresponsive, or throw system exceptions, and after such an exception it may no longer be in the expected state. In that situation, the solution must be designed so that each new transaction starts from a known, stable state, and if recovery fails, the application should be reset.
Why A is correct
A. Add clean up logic to get the application in the right position after Apply Queue Item Result.
This is important because after each transaction, especially after processing a queue item, the application may need to be restored to a known state so the next item is processed correctly. If an exception occurs, cleanup after the result is applied helps ensure the app does not remain stuck in an intermediate screen or dialog.
Why C is correct
C. Instruct the developers to build objects capable of navigating the application back to the home position.
This is a good design practice. If the app becomes unstable, reusable recovery/navigation objects can bring it back to a known home or landing page. That makes the automation more resilient and easier to recover after exceptions.
Why D is correct
D. Restart the application if attempts to navigate back to the home position fail.
This is the fallback strategy. If the bot cannot recover the app by navigating normally, restarting the application is often the safest way to guarantee a clean state before continuing with the next case.
Why the other options are not correct
B. Kill the application after each case and log back in to ensure the next case starts in the right position.
This is too aggressive and inefficient as a standard approach. Restarting after every case is not the preferred design if the application can usually be recovered more gracefully. It can also increase processing time and create unnecessary overhead.
E. Move Log into Application to be before Work Step 1 and move Log Out of Application to be after Step 3.
This does not address the main problem. The issue is not just when login/logout happens, but how to recover from exceptions and unstable application states during or after processing.
F. Add clean up logic to get the application in the right position before Work Step 1.
Cleanup before the first work step is not the best placement for handling post-exception recovery. The application needs to be corrected after transactions or failed states, not only before the first step.
G. Add clean up logic to get the application in the right position after Work Step 3.
This is too narrowly placed. Recovery logic should be associated with the transaction boundary and general exception handling, not just after one specific step. The question is about handling exceptions and restoring a known good state in a robust way.
Summary
The best approach is:
A. Clean up after processing a queue item
C. Build navigation objects to return the app to home
D. Restart the app if recovery navigation fails
So the correct answer is A, C, D.

The correct answer is D: Check input folder, wait for files, read file and load queue, log into applications.
This question is asking which steps belong in the Preparation phase of an automated process. In automation design, the Preparation phase usually includes everything needed before the main processing can begin. That often means:
1. Checking whether input is available
2. Waiting if nothing is available yet
3. Reading the input file
4. Loading work items into a queue or internal structure
5. Logging into the required applications or systems needed for processing
Why D is correct:
- Check input folder: The process must first see whether there are any files to work on.
- Wait for files: Since files can arrive at any time, the automation needs to wait and check again if none are present.
- Read file and load queue: Once a file appears, the automation should read it and prepare the cases for processing.
- Log into applications: Before the actual case handling begins, the automation should log into Systems X, Y, and Z so they are ready when needed.
Why the other options are not as complete:
A. Check input folder, wait for files
- This includes only the initial file-detection part.
- It does not include reading the file, preparing the queue, or logging into the systems.
B. Check input folder, wait for files, read file and load queue
- This is better, but still incomplete.
- It leaves out logging into the applications, which is also part of preparation.
C. Log into applications
- This covers only the system access portion.
- It does not include handling the incoming files, which is essential in the preparation phase.
Overall:
Since preparation must include both getting the input ready and making the systems available, option D is the most complete and correct choice.

The correct answers are D and E.
Here is why:
The process describes a manual workflow where files may arrive at any time, and there may be long gaps between arrivals. In that situation, the main concern is how to handle the three systems efficiently and securely while waiting.
Why D is correct:
D. Close Y and Z down but keep X open because it is the first application needed to work a case.
This makes sense because System X is needed first to search for and find the case. If there are no files to process yet, there is no need to keep Systems Y and Z open. Keeping only the first required system open reduces unnecessary resource use and avoids leaving extra systems running idle.
Why E is correct:
E. Log out while waiting and log back in when a file arrives.
This is also appropriate because long waiting periods may require users to log out for security or system policy reasons, and then log back in when new work becomes available. This is a practical way to handle unpredictable file arrivals without leaving sessions open indefinitely.
Why the other options are incorrect:
A. Nothing because they will not have been started if no files have arrived yet.
This is not the best answer because the question asks what to do if files may arrive with long intervals between them. Once work has started, some systems may already be open. Also, "nothing" does not address controlling already opened systems during waiting periods.
B. Nothing, just leave them logged in until more work arrives.
This is usually not ideal because leaving systems open and idle for long periods can waste resources and create security or timeout issues.
C. Minimise them to keep the desktop clear.
Minimising windows may help visually, but it does not solve the problem of how to control the systems during long idle gaps. It is not a proper control strategy.
F. Stop them from timing out by keeping them active while waiting for files.
This is generally not appropriate. Artificially keeping systems active is usually against good practice because it can be unnecessary, insecure, and may violate policy.
Summary:
When there may be long gaps between incoming files, the best controls are to shut down unnecessary systems while waiting and to log out until new work arrives. Therefore, D and E are correct.

The correct answers are B and C.
Here is why:
The key requirement is:
notes must always be added to Systems X and Y, no matter whether System Z is updated or not.
This means the process must ensure that note-writing happens in both of these situations:
1. when the case passes validation and System Z is updated
2. when the case fails validation and is rejected or handled as an exception
Let's examine the options.
A. Add all notes before attempting to update System 2
This is not the best answer because it only describes one ordering of actions, not a complete process design that guarantees notes are applied in both success and failure paths. Also, it says System 2 instead of System Z, and the question is about ensuring notes regardless of update outcome.
B. Create an unhappy path where notes are added as part of exception handling
Correct. An unhappy path is used when a case does not meet the required conditions or an error occurs. If notes are added in that exception flow, then cases that are not updated in System Z still get notes in Systems X and Y. This satisfies the requirement for the failure case.
C. Add notes before rejecting a case as a Business Exception
Correct. If a case does not qualify for System Z, the process should still add notes before it is rejected or marked as a business exception. This ensures that even cases not updated in System Z still have the required notes in Systems X and Y.
D. Create new cases for any cases not found in Systems X and Y so that notes can be added
Incorrect. Creating new cases is not a necessary or appropriate way to ensure notes are added. The question asks about how the process could ensure notes are applied, not about inventing new cases. This would also add unnecessary complexity and may not solve the problem correctly.
Why B and C together make sense
B describes the overall design approach: have an exception or unhappy path.
C describes a specific rule within that path: add notes before rejecting the case as a business exception.
Together, they ensure that notes are always written, whether the case is successfully updated in System Z or not.
Final answer: B and C