Study guide

2.2 Design Object Security & Dependency Tracking

Appian Certified Associate Developer ACD101

Track your progress as you read

Finished sections get a check mark.

1 Chapter 1: Platform Architecture & Environments

1.1 Appian Platform Architecture & Core Capabilities 1.2 Appian Designer, Applications & Object Containers 1.3 SDLC Environments, Deployment & Community Resources

2 Chapter 2: Security & Platform Governance

2.1 Group Hierarchies & Role-Based Access Control 2.2 Design Object Security & Dependency Tracking 2.3 Appian Design System & UX Governance

3 Chapter 3: Relational Data Modeling & CDTs

3.1 Custom Data Types (CDTs) & Schema Design 3.2 Data Stores, Entity Mapping & Table Publication

4 Chapter 4: Data Persistence Operations & Query Entity

4.1 Querying Relational Data with a!queryEntity 4.2 Data Modification & the Write to Data Store Entity Smart Service

5 Chapter 5: Records Architecture & Data Fabric

5.1 Record Types Architecture & Synced Data Sources 5.2 Record Relationships & Custom Record Fields

6 Chapter 6: Record Views, Actions & Record Queries

6.1 Record List Configuration, Headers & Views 6.2 Record Actions & Querying Records with a!queryRecordType

7 Chapter 7: Process Model Architecture & Task Design

7.1 Process Model Canvas, Lanes & Process Variables 7.2 User Input Tasks, Activity Chaining & Assignment 7.3 Script Tasks & System Smart Services

8 Chapter 8: Process Orchestration, Sub-Processes & Exception Handling

8.1 Workflow Gateways & Branching Logic 8.2 Sub-Process Design: Synchronous vs. Asynchronous 8.3 Process Escalations, Deadlines & Exception Events

9 Chapter 9: SAIL Interface Design & State Management

9.1 SAIL Framework & Component Hierarchy 9.2 Local Variables & Dynamic Refresh Behaviors 9.3 Rule Inputs, Component Parameters & Two-Way Binding

10 Chapter 10: Advanced Interface Components & Sites

10.1 Read-Only Grids and Editable Grid Layouts 10.2 Form Validations, Error Handling & Dynamic Display 10.3 Appian Sites, Navigation & Portal Configuration

11 Chapter 11: Expression Rules & Functional Data Manipulation

11.1 Expression Rule Architecture & Function Namespaces 11.2 List Processing & Looping with a!forEach 11.3 Conditional Logic & Decision Objects

12 Chapter 12: Query Optimization, Testing & Debugging

12.1 Expression Rule Testing, Assertions & Test Cases 12.2 Query Construction & Performance Best Practices 12.3 Error Handling, Type Coercion & Expression Debugging

2.2 Design Object Security & Dependency Tracking

Key Takeaways Explain This Topic AI

Appian enforces security across three distinct structural tiers: Application Security (container and packaging access), Folder Security (baseline permissions), and Individual Object Security (granular ACLs).

Rule-folder security applies while inheritance is enabled; process models never inherit the process-model folder role map.

Precedents represent upstream objects that a selected object relies upon to function, while Dependents represent downstream objects that rely upon the selected object, forming the foundation of impact analysis.

Check missing precedents when preparing a package and verify that omitted shared dependencies already exist in the target.

Last updated: October 2026

Design Object Security & Dependency Tracking

In enterprise low-code development, deploying reliable applications requires rigorous control over object security and an intimate understanding of inter-object relationships. Appian manages thousands of interconnected design objects—including interfaces, expression rules, custom data types, integrations, and process models—through a centralized dependency tracking engine. This section covers Appian's multi-tiered security model, inheritance mechanics, bidirectional dependency analysis (Precedents and Dependents), pre-deployment verification protocols, and object lifecycle governance.

The Multi-Layered Object Security Architecture

Security in Appian Designer is structured across three distinct layers: Application Security , Folder Security , and Individual Object Security . Understanding the boundary of each layer is essential for both development governance and passing the ACD101 exam. ┌────────────────────────────────────────────────────────┐

  • │ 1. Application Layer (Packaging, Export, Container) │
  • │ └─ Manages application metadata and package bundling│
  • ├────────────────────────────────────────────────────────┤
  • │ 2. Folder Layer (Default Security Baseline) │
  • │ ├─ Rule Folders (Rules, Interfaces, Integrations) │
  • │ ├─ Process Model Folders (Process Models) │
  • │ └─ Document Folders / Knowledge Centers (Files) │
  • ├────────────────────────────────────────────────────────┤
  • │ 3. Individual Object Layer (Granular Object ACL) │
  • │ └─ Specific object permissions (Admin, Viewer, etc.)│
  • └────────────────────────────────────────────────────────┘
  • 1. Application-Level Security

The Application container represents a logical grouping of design objects that deliver a business capability. Application security controls who can view, edit, package, and deploy the application container itself:

Administrator : Can modify application properties, configure application security, delete the application container, export application packages, and import patches.

Viewer : Can view the application in Appian Designer and inspect contained objects (provided object-level security permits it).

Critical Distinction : Granting a user or group Administrator access to an Application does not grant implicit access to the underlying objects inside it. Each contained object evaluates its own Access Control List (ACL).

2. Folder-Level Security

Folders serve as the primary security incubator for design objects. Appian enforces specific folder types for distinct categories of artifacts:

Rule Folders : Contain interfaces, expression rules, decision tables, integrations, and constants.

Process Model Folders : Contain process models.

Document Folders & Knowledge Centers : Contain uploaded documents, generated PDFs, and child document folders.

Folder security acts as the default security baseline. When a developer creates a new rule or interface within a Rule Folder, the new object automatically inherits the security role assignments configured on that parent folder.

3. Individual Object-Level Security

Every design object possesses an independent Access Control List (ACL). Even after inheriting security from a folder, an individual object's security dialog can be modified to grant more restrictive or broader access to specific groups. Furthermore, certain objects do not reside inside Rule Folders—such as Record Types , Data Stores , Sites , and Groups —and must have their security configured directly on the object itself.

Security Inheritance by Object Type

Managing security across hundreds of objects manually is error-prone. Appian provides object-specific inheritance mechanisms to streamline administrative governance:

Rule-Folder Inheritance

Rules, constants, interfaces, decisions, and integrations saved in a rule folder normally inherit its security. While inheritance remains enabled, the parent role map applies. Disable inheritance only when an intentional separate role map is needed, and verify the resulting access with the affected business users.

Process-Model Folders

A process model does not inherit security from its folder, either initially or continuously. Configure the model's permissions explicitly. Default application security groups can prepopulate role maps during creation; this is distinct from folder inheritance.

Runtime Context

A task's assignment and run-as configuration determine who performs its work. Running as the process designer uses that configured user's permissions, not an unconditional system-administrator context. A model's Initiator role permits starting it; it does not grant every data permission needed by every node.

Dependency Tracking: Precedents vs. Dependents

Appian applications contain networks of referenced objects; do not assume the dependency graph is acyclic. To safely modify, refactor, or delete objects, developers rely on the Precedents and Dependents analysis tools built into Appian Designer.

Dependency Type Definition Directionality Real-World Example

Precedents Objects that the selected object relies upon to execute successfully Upstream (Incoming) An Interface relies on a Constant, an Expression Rule, and a Custom Data Type (CDT).

Dependents Objects that rely upon the selected object to function properly Downstream (Outgoing) A Constant is used inside three Interfaces and two Process Models. Upstream Precedents Target Object Downstream Dependents

  • ┌────────────────────┐ ┌───────────────┐ ┌─────────────────────┐
  • │ Constant: MAX_LIMIT│ ─────────► │ │ ──────────► │ Interface: CaseView │
  • ├────────────────────┤ │ Expression │ ├─────────────────────┤
  • │ Rule: formatName │ ─────────► │ Rule: │ ──────────► │ Process: CaseReview │
  • ├────────────────────┤ │ getCaseSummary│ ├─────────────────────┤
  • │ Record: CaseRecord │ ─────────► │ │ ──────────► │ Site: Operations │
  • └────────────────────┘ └───────────────┘ └─────────────────────┘
  • Performing Impact Analysis

Before modifying an existing expression rule—such as changing an input parameter from an integer to a list of integers, or altering the return type—developers must inspect its Dependents . The Dependents view displays every interface, process model, web API, and parent rule that invokes the target object. By reviewing dependents, developers can systematically update calling expressions across the application, preventing production runtime expression evaluation errors.

Missing Precedents and Package Export Governance

One of the most critical stages in the Appian Software Development Life Cycle (SDLC) is the pre-export verification gate. The Missing Precedents tool in Appian Designer scans the application container against system-wide object dependencies to identify any required objects that have not been included in the application package.

Why Missing Precedents Occur

Missing precedents typically arise from three development scenarios:

Unpackaged Supporting Objects : A developer creates a new constant or helper rule while building an interface, but forgets to explicitly add that helper object to the application container.

Cross-Application References : An application references shared utility rules or global branding constants residing in another application that has not yet been exported or deployed.

Modified Data Types or Data Stores : A process model references a newly altered CDT or data store entity that was omitted from the deployment package.

Important

Always run the Missing Precedents check before exporting any application package. Omitting a required constant, expression rule, or CDT will cause target deployment failures or broken runtime references.

The Deployment Risk

If an application package containing missing precedents is exported and imported into a downstream target environment (such as Staging or Production), the import engine will throw critical deployment errors:

If the missing precedent does not exist in the target environment, the import fails entirely or creates broken objects that fail at runtime.

If an older version of the missing precedent exists in the target environment, the newly deployed object may call outdated parameters, causing intermittent expression failures.

Mandatory Protocol : Developers must always run the Missing Precedents check prior to exporting any application package or patch. All reported precedents must either be added to the package or verified as existing in the target environment's baseline.

Managing Object Lifecycles, Orphans, and Deprecation

As enterprise applications evolve over multiple releases, unused and superseded design objects accumulate, introducing technical debt and confusion.

Identifying Orphan Objects

An Orphan Object is a design object that has zero dependents, is not included in any active application package, and is not linked to any site, portal, record type, or process model. Developers identify orphans by opening suspected objects and reviewing their Dependents tab. Zero detected dependents is only a candidate for investigation. Check entry points, running processes, external consumers, and references that analysis may not identify before classifying it as unused.

Safe Object Deprecation Protocol

Deleting design objects prematurely can cause catastrophic cascade failures across an application. Appian development teams follow a disciplined deprecation lifecycle:

Dependent Audit : Confirm that the Dependents list is completely empty. If active dependents exist, refactor them to use the replacement object first.

Quarantine & Renaming : Rename the object using a standardized organizational prefix (e.g., ZZ_DEPRECATED_calculateTax ) and move it to a dedicated Archive / Deprecated Rule Folder.

Release Observation : Leave the quarantined object in the development environment for at least one full sprint cycle to catch any dynamic expressions or unindexed references.

Permanent Deletion : Delete the quarantined object in the development environment and follow an explicit target-environment cleanup procedure. Removing or deleting an object in the source does not make an ordinary package automatically delete it in the target.

Source checked 2026-10-18: Appian folder and document management .