Skip to main content
Question

Is your application record-based or CDT-based? What are the key differences between CDTs and Records, and why did you choose Records?

A
Anonymous
December 27, 2025

Answer

A custom data type (CDT) defines the structure of data: its fields and their data types. A record type represents a business entity and adds built-in ways to retrieve, relate, secure, and display that data.


Older Appian applications usually used CDTs with Data Store Entities (DSEs) to work with databases. For new development, record types are generally preferred because they simplify data access, support relationships, offer security features, and can use Data Sync for faster access. They don’t replace CDTs entirely, though, and each has cases where it fits better.


How each one works

Take a telecom application with this Customer table:

customerId

customerName

status

101

John

Active

102

Sarah

Inactive

With a CDT, you create a Customer_CDT with customerId (Integer), customerName (Text), and status (Text). It only describes how the data is shaped. To read from the database the traditional way, you map a DSE to the CDT, then use a!queryEntity() to query it or the Write to Data Store Entity smart service to update it.


With a record type, you create a Customer record type and connect it to the Customer table. You can then:

  1. Retrieve customer details with a!queryRecordType().
  2. Show customer information in a grid.
  3. Configure record views and related actions.
  4. Apply record-level security.
  5. Create relationships with other record types.
  6. Use Data Sync to speed up data access.

These all come built in through one data model, so you don’t assemble each piece by hand.


Key differences

Feature

CDT

Record type

Primary purpose

Defines a data structure

Represents and manages business data

Database access

Traditionally through a DSE

Through a configured record data source

Query function

a!queryEntity() with DSE

a!queryRecordType()

Relationships

Through CDT/DSE mappings or custom logic

Built-in record type relationships

Data Sync

Not directly supported

Supported

Security

Uses application and data-source security

Supports record-level and field-level security

UI development

More manual configuration

Built-in record views, actions, and record-powered components

Process variables

Supported

Supported

Best suited for

Legacy applications and specific integration requirements

Modern Appian applications


Example: Telecom customer support application

Support agents need to see customer details and their support tickets. There are two tables.

Customer:

Customer ID

Name

101

John

102

Sarah

Support Ticket:

Ticket ID

Customer ID

Status

5001

101

Open

5002

101

Closed

5003

102

Open

With CDTs

You create Customer_CDT and SupportTicket_CDT and map each to its table through a DSE. When an agent opens John’s details, the application:

  1. Queries the Customer DSE for John’s information.
  2. Queries the Support Ticket DSE for tickets where Customer ID equals 101.
  3. Displays the results in an interface.
  4. Uses extra expression logic to count his open tickets.


This works, but you build and maintain the queries and logic yourself.

With record types

You create Customer and SupportTicket record types and configure a one-to-many relationship between them on customerId. Appian can then retrieve the customer and the related tickets through record type queries. When an agent opens John’s record, the interface shows:

Customer name: John, Customer ID: 101

Ticket ID

Status

5001

Open

5002

Closed

Total tickets: 2. Open tickets: 1.

A custom record field can calculate the number of open tickets for each customer. You can reuse the relationship and that field across interfaces and reports, so there is less repeated code and related data is accessed the same way everywhere.


When to use record types

Use them for new applications. An employee management app with employee lists, profiles, approval actions, and reporting is a typical case.

They also suit related data. If a Customer record type has a one-to-many relationship with Orders, you can retrieve customer and order information through that relationship without writing separate database queries for each screen.


Synced record types store optimized copies of source data in Appian’s data service, which can reduce repeated requests to external databases or APIs. A support dashboard that often displays thousands of tickets can benefit from this. Performance still depends on application design, sync configuration, and how much data you retrieve.

Custom record fields handle calculations and aggregation over related data, such as the number of open tickets assigned to each support agent.

Record types can also represent data from different supported sources and connect it through relationships. If customer details live in Salesforce and tickets live in a database, record relationships can give a unified view of the customer and their support history.


When to use CDTs

Many existing Appian applications use CDTs and DSEs for database operations. If an older HR application uses an Employee_CDT with the Write to Data Store Entity smart service and works correctly, there is no need to replace every CDT right away.


Some legacy smart services work through DSEs. Export Data Store Entity to Excel, for example, uses a DSE configuration, which is based on CDT mapping.

Some SOAP integrations use CDTs generated from WSDL definitions, and certain Java plugins may require CDT-based inputs or outputs. If a third-party SOAP service returns customer details in a defined XML structure, a CDT can represent that structure in Appian.


CDTs can also hold temporary structured data during process execution, such as a set of validation results passed between process nodes that doesn’t need to be stored as business records. Record types can also be used as process variables, so you don’t need a CDT just because you want a structured process variable.


Using both

Real projects often use both. Say an older application already stores customers through Customer_CDT and a Customer DSE, and the business now wants a dashboard showing total customers, active customers, open support tickets, and customer support history.


You can create Customer and SupportTicket record types on the same database tables. The existing process models keep using their CDTs and DSEs, while the new dashboard uses record type queries, relationships, and custom record fields. That modernizes the application without changing functionality that already works.


Appian Documentation References:

  1. Custom Data Types
  2. Reference Record Types in Applications
  3. Using Record Types in Existing Applications
  4. Appian Data Service
  5. Write Records Smart Service

Check yourself

Question 1 of 5, on what the answer above covers.

  1. 1.
    Which statement best describes the difference between a CDT and a record type?
JuniorSeniorRecords