Scribd
Upload
128 views

Appian Interview Questions

Uploaded by

ashwani13092022
Copyright
© © All Rights Reserved
Available Formats
Download as XLSX, PDF, TXT or read online on Scribd
128 views

Appian Interview Questions

Uploaded by

ashwani13092022
Copyright
© © All Rights Reserved
Available Formats
Download as XLSX, PDF, TXT or read online on Scribd
You are on page 1/ 10

Public #_x000D_

Categoty Question
PM What is the main difference between an Activity Class Parameter and a Process Variable?

PM What are some of the main things to configure on a new Process Model after creation?

Gateways Explain the 4 types of Process Model gateways.

Gateways A user is submitting an application for approval, and the application may need to go through
one or more approval flows. Which gateway should be used?
PM What are the two ways a sub-process can execute from a parent process?

Record What 3 kinds of backed Record Types are possible in Appian?

PM When calling a sub-process, what does it mean to pass a variable as a reference?

PM What is Activity-Chaining? What is the Activity-Chaining limit?

PM What is MNI? What is the MNI limit?

Fundamental What is the difference between a Process Model and a Process Instance in Appian
Public #_x000D_

Answer
An Activity Class Parameter (ac!) has its scope limited to a single Process Model node. A Process
Model Variable (pv!) can be used anywhere within the process.
Process Display Name, Setting up Security, Notification preferences(Alerts), and Data
Management(Delete/Archieve Process).
AND: Split or merge Process Model flows. AND gateways do not use/require conditions. All flows
that emerge from the AND gateway (outgoing) are executed simultaneously. In addition, the AND
gateway will wait for all flows to arrive before continuing (merging flows).
OR: It can execute zero or more outgoing flows. Executes all flows that meet the conditions
specified. Used with one incoming flow.
XOR: Will execute a single outgoing flow based on conditions specified. Used with one incoming
flow.
Complex: Can be used to wait for specific/all incoming flow(a), and can execute one or more
outgoing flow(s). It can be used as a combination of other gateways.

OR (or Complex)

Synchronously: Pauses the parent process until the sub-process completes.


Asynchronously: The parent process executes the sub-process but continues execution.
Entity-Backed: Records are drawn from a Data Store Entity (from a database); each record in an
Entity-Backed Record corresponds to one row in the Data Store Entity (database table).
Expression-Backed: Most flexible. Records are typically drawn from source types outside of Appian,
through an Integration that calls an external system.
Process-Backed: Records are drawn from Process Model instances. The record is built using process
properties and variables.
SalesForce

A pointer to the process variable is passed to the child process, and it can make changes directly to
the parent process. Any changes made to the variable are immediately reflected in both parent and
child process(es).
Activity-Chaining: Allows a user to perform attended tasks (interfaces) back-to-back without having
to leave the flow. By default, there is an upper limit of 50 chained nodes between attended
activities.
Multiple Node Instances. This occurs when you instantiate a process model node multiple times, for
example, by creating a loop over the node. Appian has a hard limit of 1000 instances of any node. If
you attempt to instantiate more than 1000 instances of a node in a process, the process will hang.

Process Model: This is essentially a blueprint or template for a workflow


Process Instances: These are the individual executions of a process model.
Category
Performance Tuning & Optimization

Security Best Practices

Data Management
Version Control & Team Collaboration

Error Handling and Debugging


Question
How would you optimize a slow-performing process model in Appian?

How do you ensure data security within an Appian application?

How do you manage state and pass data between interfaces in Appian
How do you handle version control and concurrent development in
Appian

What strategies do you use for error handling and exception


management in Appian
Answer
Analyze Process Bottlenecks: Utilize Appian’s process analytics to identify any delays or
bottlenecks in the process flow.
Optimize Data Access: Ensure that data-heavy operations use efficient queries and are
paginated if necessary to reduce load times.
Parallelize Tasks: When possible, structure the process to execute tasks in parallel to
reduce the overall execution time.
Simplify Decision Logic: Review and streamline complex decision logic to reduce the
evaluation time.
Use Caching Wisely: Implement caching for frequently accessed data, taking care not to
overuse it which can lead to stale data issues.

User Authentication: Implement robust authentication mechanisms, such as SSO, to


verify user identities.
Role-Based Access Control (RBAC): Define and enforce user roles to control access to
data and functionality within the application.
Data Encryption: Utilize encryption for data at rest and in transit to protect sensitive
information.
Audit Trails: Maintain audit logs to track user actions and changes within the application.
Process Variables: When designing process models, you can define variables that hold
data and can be accessed by any task or node within the process.
Rule Inputs: Interface objects can be designed to accept inputs. These rule inputs behave
like parameters and can be passed data when the interface is called.
Local Variables: Within an interface, you can define local variables to hold data
temporarily.
Storing Data in Data Store Entities: You can persist data between interfaces by storing it
in a database through Data Store Entities (DSEs).
User-Specific Data Management: Appian allows for user-specific data storage through
User Record Data or using the User and Group data types.
Version History: Appian keeps a history of changes made to objects, allowing developers
to track changes and revert to previous versions if necessary.
Locking Mechanism: Objects can be locked when a user is editing them to prevent
concurrent modification.
Compare and Merge: Appian allows developers to compare different versions of an
object and merge changes.
Branching: While traditional branching as seen in Git isn’t supported, Appian
recommends using multiple development environments to simulate branches, with each
environment acting as a different branch.
Deployment Packages: Appian uses packages to bundle objects for deployment, which
can be versioned and moved through development, test, and production environments.

Here are the strategies I’ve used:

Set up roles and permissions to control who can edit which objects.
Encourage communication among team members to plan changes and avoid conflicts.
Use multiple development environments to work on large features or major changes
separately.
Regularly use the compare and merge functionality to resolve differences before they
become problematic.
Best Practice Description
Authentication Implement strong authentication mechanisms like SSO or MFA.
Authorization Define clear user roles and permissions for access control.
Data Encryption Use encryption for sensitive data both at rest and in transit.
Audit Logging Maintain detailed audit logs to monitor and review actions.
Regular Security Audits Conduct regular security audits and vulnerability assessments.
Security Training Provide security awareness training to all users.
https://interviewbaba.com/appian-interview-questions/

You might also like