About models

Models are the foundation of your Applaud platform. They are data models that store and organize the information powering your HR services, much like a spreadsheet, but smarter, keeping your HR data secure.

You can use models to manage HR tasks such as:

• Logging service requests
• Collecting feedback
• Running workflows
• Populating forms and pages
• Connecting to your existing systems

Each model includes properties that define the type of information it holds, such as names, dates, or departments.

How a model works

Think of a model as a dynamic table. Each row is a record (also called an instance). Each column is a property. The combination of all the properties in a row defines a complete data entry, like a time-off request or an employee profile.

Here’s an example model showing employee data:

Each row is a separate user record. Applaud assigns a unique instance ID to each record to ensure secure referencing, especially when using APIs or filtering records in workflows.

Supported property types

When building your model, you can add properties using different input types, for example:

• Text (e.g. Name)
• Email
• Date
• Lookup (e.g. Department)
• File, Boolean, Number, and more

Each property has a defined type to maintain data integrity and help Applaud process and display the information correctly. See our knowledge base article, .

Model relationships in Applaud

Models can link to each other using relationships. This is how you connect related records—like showing who submitted an expense or linking a person to their department.

You can configure the relationship when adding a new property:

• One-to-one
• One-to-many
• Many-to-many

For example:

• A person may submit many expense claims (one-to-many).
• An expense claim must include one or more currencies (many-to-many).

You can also enable inverse relationships to retrieve related records in both directions. This is especially useful when using APIs, for example:

• /person/123/manager — returns the person’s manager
• /person/123/direct-reports — returns the person’s direct reports

See it in action

Here’s an example that links three models:

• Person
• Expense claim
• Currency

Using model relationships, you can:

• Display a list of expenses submitted by a specific person
• Filter results by department
• Trigger approval workflows automatically when a new record is created

A model in Applaud works like a smart spreadsheet that stores and organizes the information in your HR portal. Each model stores and organizes the data for your HR tasks, such as time-off requests, employee profiles, or expenses, in a clear structured way. And like in a spreadsheet, each model holds information for different data types. Think of these as the columns in your spreadsheet; these are called "properties" and can be different types of data, like text, number, date, or even a lookup, like the drop-down you can create in spreadsheets. Then, if you think of each row as a complete record across all the columns, it's known as an instance. It combines all the property values for a specific item, like a single time-off request or an employee profile.

After creating your model and adding properties, you can input values into them. Values that relate to each other belong to the same record or instance. 

This table presents an example of a model with four instances, each having its own unique ID. 

The property types used in this example:

• Text: Name
• Email: Email address
• Text: Job Title
• Lookup: Department  

Each property has a specific data type, essential for maintaining data integrity within the model.

Applaud uses the unique instance ID to ensure your employees only see their data. For example, on a profile page, the ID tells Applaud which name, job title, and department to show, keeping the experience personal and secure. For example, if you want to create an employee directory, you need to decide which information to show about employees, such as Name, Job, Department, etc. Then, when you select a person's name, you can open another page to view the other relevant data specific to that person. This image shows the instance ID for this person's record in the model. It's how Applaud knows to display only the other property values for this instance in the detail block on this page.

Model relationships

You can link models and create a relationship to use more than one model's data in the same function, for example, when adding content blocks to pages or using the models' properties in a workflow step. You can see a model's relations on its Schema page. The relations describe how the models interact with each other.

Example data models in Applaud

If we want to design a simple Expense claim app, we could have a Person model, an Expense claim model, and a Currency model. Then we would need to link them using relationships.

Person model and Expense claim model relationship

Firstly, let's look at the relationship between the Person and Expense claim models. For example, what's the least number of expense claims a person could make? And what are the most?
A person might never make an expense claim, or they could make numerous expense claims. To illustrate this, we use the "zero or many" notation.
Now, let's consider the reverse relationship. An expense claim can only ever have one person. To illustrate this, we use the "one (and only one)" notation.

Expense claim and currency data model relationship

Now let's look at the relationship between the Expense claim and Currency models.
An expense claim must have at least one currency item but could have many Currency items on the claim. To illustrate this, we use the "one or many" notation.
In the reverse relationship, currency types can exist with no one making an expense claim, or a person can make an expense claim with many currencies. To illustrate this, we use the "zero or many" notation as we did previously.

Inverse model relationships

You can link a model back to itself, which creates an inverse relationship. For example, you can add a foreign-key type property to a model and choose the model to which you're adding the property. Applaud requires you to give the inverse relationship a name. For example, if you add a foreign key type property to the Person model and call it "Manager," you can call the inverse relationship "Direct reports."

Inverse relationships are beneficial when calling APIs because you can retrieve data such as:

• /person/123/manager - get the person's manager
• /person/123/direct-reports - get a person's direct reports

Tasks you can perform

• Create a new model
• Add a property to your model's schema
• Use HTTP API methods to interact with data in your model's properties
• Add an access control policy
• Import new or updated data into your model
• About model data exports
• Create a workflow

See more:

• About a model's schema
• About a model's API
• About access control policies
  • About filters
• About model data imports
• About model data exports
• About model workflows

Model reference:

• Models page
• Model dialog