100+ Free Appian ACD200 Practice Questions

Pass your Appian Certified Senior Developer exam on the first try — instant access, no signup required.

✓ No registration✓ No credit card✓ No hidden fees✓ Start practicing immediately

Not published Pass Rate

100+ Questions

100% Free

1 / 100

Question 1

Score: 0/0

In an Appian process model, you have a sub-process called from a parent process. To prevent the parent from waiting for the sub-process to complete and instead let it run independently, which sub-process configuration option should you use?

Run synchronously (None - run in same thread)

Run asynchronously

Defer the start of the process

Disable activity chaining

to track

2026 Statistics

Key Facts: Appian ACD200 Exam

Exam Items

Appian Senior Developer blueprint

60 min

Exam Duration

Appian Senior Developer blueprint

60%

Cut Score

Appian Senior Developer page

$250

Exam Fee (USD)

Appian Certification Program

18 months

Credential Validity

Appian Certification Maintenance

ACD100

Prerequisite

Associate Developer credential required

The Appian Certified Senior Developer (ACD200) is a 50-item, 60-minute remotely proctored exam delivered by Meazure Learning. The standard fee is $250 USD per attempt (50% discount for Appian Partners) and the cut score is 60%. The blueprint covers five domains: Application Design and Development (28%), Performance & Scalability (22%), Data Management (20%), Advanced Appian Concepts (18%), and Platform and Application Management (12%). The credential requires the Associate Developer (ACD100) prerequisite and is valid for 18 months, maintained through the quarterly Release Showcase training.

Sample Appian ACD200 Practice Questions

Try these sample questions to test your Appian ACD200 exam readiness. Each question includes a detailed explanation. Start the interactive quiz above for the full 100+ question experience with AI tutoring.

1In an Appian process model, you have a sub-process called from a parent process. To prevent the parent from waiting for the sub-process to complete and instead let it run independently, which sub-process configuration option should you use?

A.Run synchronously (None - run in same thread)

B.Run asynchronously

C.Defer the start of the process

D.Disable activity chaining

Explanation: An asynchronous sub-process call returns control to the parent immediately and lets the child execute on its own thread. Synchronous calls block the parent until the child completes, which can hurt performance for non-critical work like notifications or logging.

2Which expression function should a senior developer prefer to retrieve a record set when the record type is backed by a database entity and the result must respect record-level security?

A.a!queryEntity()

B.a!queryRecord() (also written a!queryRecordType())

C.fn!getDataSubset()

D.a!queryProcessAnalytics()

Explanation: a!queryRecordType (a!queryRecord) queries the record type so it honors record source filters, security, and any synced data-fabric behavior. a!queryEntity targets the underlying data store entity directly and bypasses record-level configuration like row-level security and source filters.

3You need to call a REST endpoint that requires an OAuth 2.0 access token using the Client Credentials grant. Which Appian object combination should you configure?

A.A Connected System with OAuth 2.0 Client Credentials authentication and an Integration object that uses it

B.A Web API with API key authentication

C.An Expression Rule that calls fn!httprequest()

D.A Process Model that uses a Send E-mail smart service

Explanation: Appian centralizes external auth in Connected Systems. For OAuth 2.0 Client Credentials, you store the token URL, client ID, and secret on the Connected System, then point one or more Integration objects at it. The integration handles token refresh transparently.

4During load testing, an interface that uses a!gridField with 50,000 source rows is slow to render. Which change is most likely to fix the symptom while keeping function correct?

A.Replace a!gridField with a!gridLayout and load all rows in a local variable

B.Configure the grid to query the record type with paging and sorting parameters bound to a local variable

C.Increase the JVM heap on the application server

D.Move the grid into a sub-process

Explanation: a!gridField (recordType-backed) is designed to query only the visible page; binding pagingInfo and sort to a local variable lets Appian fetch ~25 rows per page instead of 50,000. Pulling all rows into a local variable or switching to a!gridLayout removes paging and worsens the problem.

5Which deployment artifact should be used to move a tested set of design objects from a TEST environment to a PRODUCTION environment in Appian?

A.A direct database export of the I7P_ schema

B.A patch ZIP package created in Appian Designer with the selected objects and dependencies

C.A copy of the Appian application server filesystem

D.An export of the Tomcat conf folder

Explanation: Appian supports promoting changes through application packages and patch packages exported as ZIP files from Designer (or via the Deployment APIs). The package preserves dependencies and import order; copying database schemas or filesystems is not a supported deployment method.

6In a process model, an integration call inside a Script Task occasionally raises a runtime exception. Which mechanism allows the process to recover and continue down a defined error path?

A.Add a flag to the integration response

B.Attach an Exception flow from the Script Task and route it to a recovery node

C.Wrap the integration in a try/catch expression

D.Increase the activity timeout to infinity

Explanation: Process model nodes expose an exception flow that fires when the activity raises an unhandled error. Connecting that flow to a recovery node (notification, compensating step, retry sub-process) lets the model continue without leaving an orphaned task. Appian expressions have no try/catch syntax.

7Which statement best describes the role of a!localVariables in performance-sensitive interfaces?

A.It evaluates each variable once per interface refresh, caching the result for the rest of the expression

B.It always re-evaluates every variable on every keystroke

C.It runs the variables on the database server

D.It is only used for save chains

Explanation: a!localVariables (and the refreshable a!refreshVariable inside it) evaluates each variable on the relevant refresh trigger and caches the value for the rest of that interface evaluation. This avoids recomputing expensive queries inside repeated components.

8You are designing a Web API that returns JSON. The caller must page through results. Which response design is most aligned with Appian and REST conventions?

A.Return all rows in one response and let the caller sort client-side

B.Accept startIndex and batchSize query parameters and return data, totalCount, and nextLink fields

C.Return XML so the caller can stream

D.Use a!queryEntity inside the Web API and ignore paging parameters

Explanation: Standard REST paging contracts pass batch size and start index (or page/cursor) and return the page plus a total count and a link to the next page. Web APIs in Appian commonly bind those parameters into a!pagingInfo before calling a!queryRecordType.

9Which statement about record-level security on a database-backed record type is correct?

A.Record-level security is enforced at the database with a stored procedure

B.Record-level security is configured as a security filter on the record source and is applied to every record query

C.Record-level security can only be applied via interface visibility expressions

D.Record-level security is only available for synced records

Explanation: On a record type, you configure security filters that Appian applies to every query against the record source - including a!queryRecordType, record lists, and grids. Interface-level visibility hides components but does not stop the underlying data from being returned to other queries.

10What is the primary advantage of a synced record type over a non-synced (source-backed) record type?

A.Synced records replicate the source into the Appian Data Fabric for fast in-memory queries and joins

B.Synced records always provide stronger row-level security

C.Synced records run their queries on the source database in real time

D.Synced records cannot use related action records

Explanation: Sync copies source rows into Appian Data Fabric (formerly Records Sync) so subsequent queries hit the in-memory store instead of round-tripping to the source. This dramatically reduces latency for grids, charts, and aggregations and enables cross-record-type joins.

About the Appian ACD200 Exam

The Appian Certified Senior Developer (ACD200) exam validates advanced developer skills on the Appian low-code platform: tuning process model performance with sub-processes and exception flows, designing complex SAIL interfaces with a!localVariables and a!gridField paging, working with synced record types and Data Fabric, securing record-level data, integrating external systems through Connected Systems and OAuth 2.0, exposing Web APIs with paging and auth, generating documents, and promoting changes through staged environments.

Questions

50 scored questions

Time Limit

60 minutes

Passing Score

60% cut score

Exam Fee

$250 (Appian / Meazure Learning)

Appian ACD200 Exam Content Outline

28%

Application Design and Development

Complex SAIL interface composition, save chains, activity chaining, sub-processes, exception flows, accessibility, mobile considerations, integrations, Web APIs, and document generation.

22%

Performance & Scalability

Tuning a!gridField paging, hoisting queries with a!localVariables, eliminating N+1 record queries, archiving long-running processes, pre-aggregation, engine resourcing, and capacity planning.

20%

Data Management

CDTs and casting, data store entities, synced record types and Data Fabric, record-level security, related action records, document storage, PII minimization, and shared types.

18%

Advanced Appian Concepts

Connected Systems and OAuth 2.0, SOAP / WSDL services, decision objects, plug-ins from AppMarket, expression namespaces, test cases, Quick Apps trade-offs, and rollout patterns.

12%

Platform and Application Management

Admin Console, Health Check, logs, environments, application packages and patch packages, Inspect/Compare, import customization files, security and groups, and rollback.

How to Pass the Appian ACD200 Exam

What You Need to Know

Passing score: 60% cut score
Exam length: 50 questions
Time limit: 60 minutes
Exam fee: $250

Keys to Passing

Complete 500+ practice questions
Score 80%+ consistently before scheduling
Focus on highest-weighted sections
Use our AI tutor for tough concepts

Appian ACD200 Study Tips from Top Performers

1Build a real Appian application that includes a synced record type, record-level security, an integration with OAuth 2.0, a Web API with paging, and a sub-process with exception flows - the exam's scenarios mirror that mental model.

2Memorize the five blueprint domain weights so you can pace 50 items in 60 minutes: roughly 14 questions on Application Design and Development and only about 6 on Platform and Application Management.

3Practice tuning a!gridField with paging and a!localVariables to hoist heavy queries; senior-level questions test whether you can spot N+1 query patterns and design around them.

4Be fluent with sub-process invocation modes (synchronous, asynchronous, deferred), activity chaining, and exception flow routing - many ACD200 questions hinge on choosing the right combination.

5Understand the trade-off between synced and non-synced record types: read latency, freshness lag, joinability through Data Fabric, and how record-level security filters apply to both.

6Practice configuring Connected Systems for OAuth 2.0 (Client Credentials and Authorization Code grants), handling 4xx/5xx response codes, and adding controlled retry with backoff via Timer events.

7Walk through a full deployment story: build a patch package, run Inspect against the target, deploy with import customization for environment-specific URLs, and prepare a rollback package.

8Run timed mock exams in 60-minute blocks at 50 items - you have just over a minute per item, so flag-and-return discipline is critical.

Frequently Asked Questions

What is on the Appian ACD200 exam?

ACD200 tests advanced Appian developer skills across five domains: Application Design and Development (28%), Performance & Scalability (22%), Data Management (20%), Advanced Appian Concepts (18%), and Platform and Application Management (12%). Senior developers should be fluent with sub-processes and exception flows, complex SAIL patterns including a!gridField paging and a!localVariables, synced record types and Data Fabric, record-level security, Connected Systems with OAuth 2.0, Web API paging and auth, document generation, and deployment using application packages and patch packages.

How long is the exam and how many questions does it have?

The Appian Certified Senior Developer exam is 50 items in 60 minutes. Questions use multiple-choice and multiple-response formats and are delivered online with a live remote proctor through Meazure Learning. You see your result immediately after submission.

What is the passing score for ACD200?

Appian publishes a 60% cut score for the Senior Developer exam. Your raw score must hit or exceed that threshold across the 50-item form to earn the credential. Appian rotates item pools, so the cut score is the same regardless of which form you receive.

How much does the ACD200 exam cost?

The Appian Senior Developer exam fee is $250 USD per attempt. Appian Partners receive an automatic 50% discount, bringing the cost to about $125. Recertification through quarterly Release Showcase training is free; retakes after a failure are charged the standard fee.

What are the prerequisites for ACD200?

Appian requires an active Associate Developer (ACD100) certification before sitting ACD200. Senior Developer also assumes hands-on Appian project experience - typically 6-12 months of building production-grade applications, including integrations, complex process design, record-level security, and deployment between environments.

How long is the certification valid?

The Senior Developer credential is valid for 18 months from the date earned. To remain certified, you must complete the quarterly Release Showcase training before your expiration date or pass the exam again. Lapsed credentials cannot be reinstated and require restarting at the Associate Developer level.