17.3 UiPath Apps: Action Apps, Automations & Integration Service
Key Takeaways
Apps combine pages, controls, rules, referenced Orchestrator processes, and Integration Service connections.
An app can call several focused automations, passing inputs from controls and binding outputs back.
An action app has one Action control whose schema holds input, output, and in/out properties and outcomes (one input and one Submit outcome by default).
Outcomes are mapped to Submit Action rules; the app is published and deployed to an Orchestrator folder.
Create App Task and Wait for App Task and Resume use the action app as the task interface in Action Center; Coded Action Apps use React or Angular.
17.3 UiPath Apps: Action Apps, Automations & Integration Service
Core Concept: UiPath Apps builds web interfaces for automations, without writing front-end code. The exam description lists advanced Apps topics: action apps with their action schema, apps that call multiple automations, and apps that use Integration Service APIs. Apps are built in Studio Web (app projects) or UiPath Apps Studio.
What an App Is Made Of
| Part | Role |
|---|---|
| Pages and controls | The interface: text boxes, dropdowns, date pickers, buttons, tables, edit grids, tabs, containers, file upload, and more |
| Rules | Logic attached to control events, such as a button's Click event: set values, navigate, run automations, or submit an action |
| Referenced automations | Orchestrator processes the app can start, passing input arguments and reading outputs |
| Connections | Integration Service connections that let the app call application APIs directly |
| Variables and expressions | Values shared across pages and controls |
Apps and Automations
An app can reference several processes, each doing part of the work. A customer service app might:
- Run a lookup process when the agent enters an account number, filling a table with the output.
- Run an update process when the agent edits details and selects Save.
- Run a document process that generates a letter.
Each call passes input arguments from controls and returns output arguments that the app binds to controls. Keeping the processes small and focused makes the app responsive and each automation reusable.
Apps can also use Integration Service connectors directly, for example to read records from a CRM, without a process in between. Use a process when the logic needs UI automation or complex steps, and a connector call for simple API reads and writes.
Action Apps
An action app is an app used as the interface of a task in Action Center. It replaces a form task when you need a richer interface.
Building an action app
- Add an Action control to the app (via Add control). Only one action per app is allowed. Once deployed, the app is opened through Action Center.
- The Action Properties schema opens. It starts with one input property and one Submit outcome.
- Add properties of the kinds you need:
- Input: data the workflow sends to the task.
- Output: data the reviewer returns.
- In/Out: data sent to the task that the reviewer can change. Property names must follow VB naming conventions, you can mark properties required, and complex types such as objects support sub-properties.
- Map inputs and in/out properties to input controls. A required input or in/out property should be mapped to an input control.
- Add outcomes such as Approve and Reject. Each outcome is mapped to a Submit Action rule, typically on a button's Click event.
- Publish the app, then deploy it to an Orchestrator folder (Automations > Apps > Deploy app).
Using it from a workflow
In a long-running workflow, Create App Task creates the task with a title, priority (TaskPriority.Low, Medium, High, or Critical), the deployed action app, and values for the schema's properties. Wait for App Task and Resume suspends the job until the reviewer submits an outcome, then returns the task data, including outputs and the chosen outcome.
The action app can also be a Coded Action App, a custom React or Angular application built in your own IDE.
Action App Versus Form Task
| Form task | Action app task | |
|---|---|---|
| Designer | Form designer in Studio | Apps (Studio Web or Apps Studio), or code |
| Interface | Form components | Full app pages, rules, and controls |
| Data contract | Form data (In, Out, In/Out) | Action schema properties and outcomes |
| Activities | Create Form Task, Wait for Form Task and Resume | Create App Task, Wait for App Task and Resume |
| Best for | Simple reviews and data entry | Rich reviews, lookups during review, reuse across processes |
Worked Example: Credit Limit Approval
- The action app's schema has inputs
CustomerNameandRequestedLimit, an in/out propertyApprovedLimit, and an outputComment, with outcomes Approve and Reject. - The app shows the customer's history by calling an Integration Service connector for the CRM when the page loads.
- A long-running process runs Create App Task with the request values and then Wait for App Task and Resume.
- The reviewer lowers
ApprovedLimit, adds a comment, and selects Approve, which runs the Submit Action rule with that outcome. - The process resumes, reads the outcome and
ApprovedLimit, and updates the ERP.
Common Traps
- Only one Action control per app.
- An outcome only works when mapped to a Submit Action rule.
- An action app must be deployed to an Orchestrator folder before Create App Task can use it.
- Required input and in/out properties need input controls.
When you add an Action control to an app, what does its schema contain by default?
No properties and an Approve and Reject outcome.
One input property and one Submit outcome.
One output property and no outcomes.
A property for every control on the page.
A reviewer must choose Approve or Reject in an action app. How are these outcomes connected to the app?
Each outcome is mapped to a Submit Action rule, typically on a button's Click event.
Outcomes are set by the workflow after Wait for App Task and Resume.
Outcomes are the names of the input properties.
Outcomes are configured only in Orchestrator.
Which statement about action apps is correct?
An app can contain several Action controls, one per outcome.
An action app can be used before it is deployed.
Only one Action control is allowed per app, and the app must be deployed to an Orchestrator folder before Create App Task uses it.
Action apps can only be built with React.
Sections you finish are checked off in the contents.