Appian Developer Skills Self-Assessment

In order to assess your expertise in Appian concepts, this self-assessment lists the most important 
skills necessary to effectively design applications. We recommend completing this self-assessment 
periodically to determine which skill areas you are comfortable with and which areas require more 
study.  
 
The assessment is used to diagnose capabilities of developers to determine what gaps exist. For 
each of the items displayed below, identify your score based on the following levels:  
 
Minimal/No Proficiency​ - Can identify basic facts and terms about the subject or task; 
Level 1 
can do simple parts of the task but needs to be shown how to do most of the task 
Adequate​ - Demonstrate understanding of facts and ideas by organizing, comparing, 
translating, interpreting, giving descriptions and stating main ideas; can follow step by 
Level 2 
step procedures for accomplishing a task and accomplish most parts of a task with help 
only on the hardest parts 
Competent​ - Can examine and break information into parts by identifying motives or 
causes; make inferences and find evidence to support generalizations; can identify why 
Level 3 
and when a task must be done, why each step is needed, and can do all parts of the task 
with only a spot check of work 
Highly Proficient​ - Can present and defend opinions by making judgments about 
information, validity of ideas or quality of work based on a set of criteria; can predict, 
Level 4 
isolate, and resolve problems about the task; able to complete the task quickly and 
accurately; able to tell or show others how to do the task 
 
Next to each skill is a suggested resource you can use to improve. The suggested resources 
include: 
 
Instructor Led Training and Academy Online Content - We recommend instructor-led 
T  training as the primary method to enable these skills. Academy Online is also available as a 
supplement and a resource for more in-depth content. 
Academy Online - Content in the Developer course in Academy Online at 
O 
https://academy.appian.com 
Playbook - Available from the Appian Playbook on Community at 
P 
https://community.appian.com/w/the-appian-playbook 
Community - Content available from the main page on on Appian Community at 
C 
https://community.appian.com 
D  Documentation - All documentation available from ​https://docs.appian.com 
 
 
 
  
 
 

Skill Level  Developer Skill  Resource 

  Appian Basics and Terminology   

  Describe the benefits of using the Appian platform  T 

  Describe the difference between Tempo, Sites, and Embedded  T 
  Describe the difference between a Message and a Post  T 
Define each component of a record including: Record Type, Record List, Related 
  T 
Action, Record View 
  Create a process flow diagram using BPMN  T 
  Identify the difference between the Admin Console and Appian Designer  T 
  Describe the benefits of using Appian Cloud over on-premise installations  P 
  Use Appian Community to search for answers to technical questions  C 
  Describe the benefits of using Appian on mobile devices  T 
  Describe how Appian can integrate with Robotic Process Automation tools  O 
     
  Appian Designer Basics   
Identify the purpose of using each designer objects (Connected System, 
Constant, Data Store, Data Type, Decision, Document, Expression Rule, Feed, 
  T 
Folder, Group, Integration, Interface, Process Model, Record Type, Report, Site, 
Web API) 
  Understand how to grant users access to the Appian Designer  T 
  Describe the difference between the Quick Apps Designer and Appian Designer  T 
     
  Folders and Security   
Identify the different folder types in Appian and design objects that require 
  T 
folders 
  Set the correct security on folders in the Appian Designer  T 
  Define the most common security roles in Appian  T 
     
  Users and Groups   
  Describe the key differences between Basic Users and System Administrators  T 
  Describe the purpose of using a parent-child relationship within groups  T 
  Create a group in the Appian Designer  T 
  Create a group using a process model  T 
  Set security on Appian Design objects to reference groups  T 
  Add or remove members from groups  T 
  
 
 

  Set a group membership rule  D 

     
  Custom Data Type and Data Design   
  Describe how Custom Data Types are used in Appian  T 
  Describe the relationship between a Custom Data Type and a database table  T 
  Identify 3 ways to create a CDT in Appian  T 
  Identify the types of relationships used in CDTs  T 
  Define the purpose of using XSD and configure a CDT using XSD  O 
  Configure a CDT using JPA Annotations  O 
  Define the purpose of using auto-generate for a primary key  T 
Understand what steps are required within the database and data store to 
  T 
update a CDT 
  Cast a local variable or dictionary to a Custom Data Type  T 
  Optimize queries by using views, stored procedures, or indexes  O 
  Construct a data model in Appian using the correct relationships between CDTs  O 
     
  Data Stores and Databases   
  Define the security roles available for Data Stores  T 
Identify Relational Database Management Systems (RDBMS) that can be used 
  T 
natively with Appian 
  Correctly verify changes in the database are also applied in Appian  T 
  Use SQL to create a database view and map to it in Appian  O 
     
  Rules and Constants   
  Describe the purpose of using a constant  T 
  Identify the types of data that can be used within a constant  T 
  Create a constant and reference it within an expression  T 
  Identify common data domains (prefixes) used to reference data in expressions  T 
  Create and test a basic expression rule  T 
  Explain the syntax of a sample expression  T 
  Define the purpose of using keyword syntax  T 
Given an example calculation in Excel, build a corresponding expression rule in 
  T 
Appian 
  Utilize an expression rule in a Process Model, Record Type, or Interface  T 
  Configure multiple test cases and test common inputs of an expression rule  T 
  
 
 

  Use the a!forEach() function to apply formatting to a list of values  T 

Explain the difference between Row Order, Unique, and First within a Decision 
  T 
Rule 
  Create a decision to determine an output based on multiple inputs  T 
  Create an array of values within an expression  T 
Define a dictionary and compare and contrast using dictionaries and Custom 
  T 
Data Types in an expression 
Explain the purpose of using local variables and describe when to use load() vs 
  T 
with() 
  Utilize function variables (fv!) within Appian functions  T 
  Debug common issues with expression rules  T 
     
  Process Modeling   
  Define the purpose of setting Data Management in a Process Model  T 
  Correctly configure Process Properties within a Process Model  T 
  Describe the difference between using a Start Form and a User Input Task  T 
  Define the purpose of using swimlanes  T 
  Write to a Database using the Write to Data Store Entity node  T 
Explain the difference between running a sub-process Synchronously and 
  T 
Asynchronously 
  Implement an Exception or Escalation on an activity within a Process Model  T 
  Define the purpose of setting a Process Variable as a parameter  T 
  Implement user driven and event driven processes  T 
  Debug and Troubleshoot issues with processes  T 
  Explain the effect process data has on memory usage in Appian  T 
  Describe the difference between the different types of gateways  T 
  Implement Process Models with OR, XOR, AND, and Complex gateways  T 
  Define the required properties of a User Input Task  T 
  Build a Process Model that runs multiple nodes of an activity in the process  O 
     
  Interfaces   
  Explain differences between using a form and other types of interfaces  T 
  Describe the components that can be used on an interface  T 
  Create a basic form to capture inputs from a user  T 
  Create reusable interface rules that can be referenced within other interfaces  T 
  
 
 

Given a poorly performing interface, investigate performance issues and improve 

  T 
the time to render the interface 
  Utilize smart service functions directly on an interface  T 
  Create a interface that can be used offline on a mobile device  P 
Design interfaces specifically for mobile devices to take advantage of mobile 
  T 
benefits 
  Create validations to provide guidance for users  T 
  Create an interface that follows the Appian Style guide best practices  T 
  Implement fields that hide or display based on a condition  T 
  Build an editable grid that allows adding and removing rows  T 
  Use dynamic links to enable interaction on interfaces  T 
     
  Documents   
  Define the objects required in a document hierarchy  T 
  Describe the purpose of each security role in a document hierarchy  T 
  Create a Custom Data Type that can store a reference to an Appian document  T 
  Configure an interface that enables users to upload files  T 
  Define a validation to limit the document file type that can be uploaded  T 
  Create a document in a process using a template  P 
  Display an image stored in the Appian file system  T 
  Show a document download link for a file stored in the Appian file system  T 
Understand how to scale and maintain the document management system in 
  P 
Appian 
     
  Queries   
  Compare and contrast using the Visual Query Designer and a!queryEntity()  T 
  Create a query to retrieve data from a table in a relational database  T 
  Describe the parameters of the a!queryEntity() function  T 
  Create a query with a complex filter using a!queryLogicalExpression  T 
  Define the purpose of using paging info in queries  T 
     
  Records   
  Configure an expression-based user filter  T 
  Describe the difference between a User Filter and a Default Filter  T 
  Create an expression-backed record to retrieve data from an integration  O 
  
 
 

  Identify the possible data sources for records  T 

  Implement a record with row-level security  P 
Describe differences between the grid-style and feed-style list view and 
  T 
configure both 
  Define the purpose of each security role for a Record Type  T 
  Describe the benefits of using record-centric design  T 
  Implement multiple record views in a single Record Type  T 
Correctly configure a related action to send data from a record to a Process 
  T 
Model 
Use the visibility property to conditionally display a Related Action or record 
  T 
view