Is your application record-based or CDT-based? What are the key differences between CDTs and Records, and why did you choose Records?
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:
- Retrieve customer details with
a!queryRecordType(). - Show customer information in a grid.
- Configure record views and related actions.
- Apply record-level security.
- Create relationships with other record types.
- 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 |
|
|
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:
- Queries the Customer DSE for John’s information.
- Queries the Support Ticket DSE for tickets where Customer ID equals 101.
- Displays the results in an interface.
- 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:
Check yourself
Question 1 of 5, on what the answer above covers.
- 1.Which statement best describes the difference between a CDT and a record type?
- 2.You are building a new employee management app with employee lists, profiles, approval actions, and reporting. Which approach is generally preferred?
- 3.You must use a CDT any time you need a structured process variable.
- 4.Your team builds everything with record types. In which situation do you still need a CDT?
- 5.You add a one-to-many relationship between Customer and SupportTicket and a custom record field that counts open tickets per customer. Which feature do these capabilities rely on?