Exam Name: Appian Associate Developer
Requirement(s): None
Number of items: 60 Items
Duration: 60 Minutes
Price: $200
Cut Score: 62%*

*All exam scores are final, for more information see our program policies.

This exam validates the knowledge and skills of individuals building low-code applications. This page helps you understand the expectations of an Associate, as well as provide you with resources to prepare for the exam itself.

At the start of their Appian journeys, certified associate developers have some software development and relational database experience. They have one to three months of experience and participated in two to three weeks of training with Appian and have familiarity with each of Appian’s components and object types. They also grasp some best practices surrounding the use of each object.

Associate developers, at a high level, understand the connection between Appian applications and relational databases. They can execute simple SQL database queries such as creating, altering, inserting, or updating tables. They have a general understanding of the software development lifecycle, including requirements gathering, so that they can effectively contribute to the project team.

Lastly, Appian Certified Associate Developers are part of the Appian Community and work closely with mentors to further develop their skills.

Candidates should fully prepare for an exam using the objectives below as a checklist to identify possible gaps between knowledge and the skills measured by the exam. The relative weight illustrates the approximate size of each section. It is recommended that focused preparation should be in areas where any knowledge gaps are found.

The Appian Platform (10%)

- Identify commonly used Appian resources
- Organize an application's structure (e.g., folder structure, group setup)
- Describe common Appian use cases
- Differentiate between Appian platform permissions (e.g., role-based security)
- Differentiate between user experiences (e.g., sites, tempo, embedded)

Software Development Lifecycle (SDLC) (10%)

- Recognize the roles and responsibilities of development team members
- Differentiate between the stages of the SDLC (e.g., analysis, transformation, deployment, testing, maintenance)
- Describe the scrum lifecycle of a user story
- Explain the various Agile scrum ceremonies (e.g., refinement, standup, retrospective)
- Define the use of each Appian environment used within the SDLC

Data Manipulation (17%)

- Demonstrate basic knowledge of managing data and relational databases (RDBMS) (e.g., table relationships and views)
- Explain how Appian’s objects interact with relational database management systems
- Write basic SQL statements (e.g., create, modify, update, delete)
- Troubleshoot issues with database transactions(e.g., SQL, CDTs)

Appian Process Modeling (18%)

- Identify common ways to start or trigger Appian processes
- Configure process model properties, common nodes, and user input tasks
- Implement tasks within Appian process models according to proven practices

Appian Interface Design (18%)

- Construct each of the Appian interface components
- Configure common variable types within an interface
- Configure common interface components (e.g. drop-downs, grids, buttons, validations)
- Recognize and implement Appian user experience best practices

Appian Records (15%)

- Configure an Appian Record Type object to support business requirements
- Identify use cases for each record type data source
- Design record views and lists
- Configure record and related actions

Appian Expression Rules (12%)

- Recall expression rule use cases
- Build and implement a basic function expression rule
- Implement basic testing practices during expression rule creation
- Write comprehensible expression rules in accordance with business requirements

Preparation is the key to certification success. While training is not required, we do provide specific course recommendations that provide you with skills validated by the exam. It’s important that you couple your technical training and familiarity with Appian documentation  with practical application to ensure your highest chances for success on your exam. Use the below resources to guide your preparation based on a thorough review of the exam objectives.

Resources:

- Appian Developer Learning Path
- Appian Applied Developer Course
- Appian Documentation
- Appian Methodology
- Developer Playbook
- Associate Developer Practice Test

The exam objectives below reflect a future version of the exam and can be used for beta exam preparation. Specific preparation resources and section level percentages are not included for beta.

Exam development participation including beta is only open to Appian Employees and Partners. To learn more about Appian exam development including beta testing, please visit the Exam Development page. 

Introduction to the Appian platform

- Identify commonly used Appian resources (e.g., online docs, Appian Max, knowledge base)
- Identify and organize an application's structure (e.g., application object, folder structure, group setup)
- Describe Appian use cases and capabilities for solving business problems (e.g., process mining, RPA)

General Appian principles

- Differentiate between Appian platform permissions (e.g., role-based security)
- Differentiate between Appian design objects (e.g., process, records, sites, interfaces, expression rules)
- Define the use of each Appian environment

Data persistence

- Demonstrate basic knowledge of managing data and relational databases
- Employ CDTs and query entities to read and write to the database
- Utilize records and query record types to read, write, and aggregate information from the database.
- Recognize necessary steps in updating the underlying data model

Appian development: Process models

- Recognize common ways to start a process
- Define the steps to create, debug, and publish a process model
- Configure commonly used Workflow nodes and Smart Services (e.g., start and end, script task, sub-process)
- Describe the flow of data in a process

Appian development: Interface design

- Construct an interface
- Configure and use local variables and rule inputs
- Configure common interface components (e.g., drop-downs, grids, buttons, validations)
- Recognize and implement best practices outlined by Appian for interface design
- Perform interface testing and troubleshooting

Appian development: Records

- Configure a basic record by connecting to an existing data source or using codeless data modeling
- Design record views and lists
- Configure record actions
- Configure record relationships

Appian development: Expression rules

- Given an expression rule, interpret the purpose and output of the rule
- Build, implement and use a basic function expression rule
- Leverage test cases to ensure the quality of expression rules
- Recognize and implement best practices outlined by Appian for expression rules