Hey everyone 👋

I want to share a new idea I’ve been testing lately — we’ll avoid using Static Entities completely, and instead create Server Functions that return the needed lists.

This way, we can keep the same behavior as Static Entities but save several Application Objects (AOs) at the same time.

In the example below, I’ll show a simple end-to-end demo where this approach helps me save 3 AOs at once 🚀

Here’s the main concept:

• No Static Entities

• Replace them with Server Functions that return lists

• Keep it reusable, simple, and AO-efficient

👇 Check out the demo below!

🧩 The old approach — using Static Entities

Let’s start with a simple example. I have an entity called Activity with the following attributes:

• Name (Text)

• Description (Text)

• StatusId (Identifier)

• PriorityId (Identifier)

• ClusterId (Identifier)

In a traditional setup, these three “Id” attributes are Foreign Keys to Static Entities:

• Status – contains values like Open, In Progress, Closed

• Priority – contains Low, Medium, High

• Cluster – contains Automation, AI, Data Management, etc.

🚀 The new approach — replacing Static Entities with Server Functions

Now, let’s move to the new approach. In this version, I’ve removed all Static Entities — Status, Priority, and Cluster — completely.

The ActivityNew entity structure stays the same in terms of logic, but the data types for the linked attributes are changed from Identifier to Text:

⚙️ Step 1 – Creating a base structure for our “static” data

Before building the Server Function, let’s first create a structure that will represent our “static entity” values. This structure will be reused by all our functions (Status, Priority, Cluster, etc.).

Here’s how to do it:

1. Go to the Data tab → Structures.

2. Create a new structure and name it strStaticEntity.

3. Set Public = Yes (or No, depending on whether you want to reuse it across modules).

4. Add two attributes to this structure:

   • Id (Text) — represents the ID or code value.

   • Label (Text) — represents the display name. (Of course, you can add more attributes if needed — for simplicity, I’ll keep just these two.)

This structure will act as the base for all the lists that we’ll expose through our Server Functions.

🧠 Step 2 – Creating the Server Function

Now that we have our base structure (strStaticEntity), let’s move on and create the Server Function that will return our “static” data.

1. Go to the Logic tab.

2. In the Server Actions section, create a new folder named StaticEntities — this will help us keep all our functions organized in one place.

3. Inside this folder, create your first Server Function and make sure the Function Property is set to yes

4. 

💡 Naming convention: I like to use a small prefix to keep things consistent. For example, I’ll name this function seStatus, where:

• se stands for Static Entity (so it’s easy to recognize what type of function it is),

• Status represents the type of data it will return.

So the full name seStatus clearly indicates that this function behaves like a Static Entity for Status.

Later, I can follow the same pattern for other functions:

• sePriority – returns the priority list

• seCluster – returns the cluster list

🧠 Step 3 – Defining inputs and outputs for seStatus

Now that we have the function created, we need to define its input and output so it can be used in multiple ways.

1. Input:

   • Name: Identifier

   • Data type: Text

   • Mandatory: No (set to No, because this input is not required all the time)

   • This input will allow us to retrieve a specific label or value when needed. Later, I’ll show exactly how and where to use it in the app.
   • 
     
   
   

2. Output:

   • Name: ListOfStatus (or any descriptive name you prefer)

   • Data type: List of strStaticEntity

   • This output will return the full list of statuses, which we can use to populate dropdowns or for other logic that normally relied on the Static Entity.
   
   

3. 

🧠 Step 4 – Building the function logic in the flow

Now it’s time to define the logic inside our seStatus function.

1. Drag a ListAppendAll action into the flow.

2. For the Source property of ListAppendAll, use the output list we previously created (e.g., List).

   • This will allow us to append multiple items to the list at once.

   • 

3. Next, we will add individual items representing each status (like Open, In Progress, Closed) to the list using ListAppend actions.

   • Each item will be a strStaticEntity record, with its Id and Label set.

By clicking on the plus Sign 

🧠 Step 5 – Adding conditional logic and filtering

The next step is to drag an If widget into the flow.

Why are we doing this? We want to check if the function has been called with the Identifier input:

• If Identifier = "" (empty), the function will do nothing and simply return the full list.

• If Identifier ≠ "" (not empty), the function will return only the matching label for the given Identifier.

Here’s how to implement this:

1. Drag an If widget into the flow and check:

   Identifier = ""

2. On the False branch (Identifier is provided):

   • Drag a ListFilter server action into the flow.

     • If you don’t have it yet, bring it in from Manage Dependencies → System.

   • Set the List property of ListFilter to our function’s output list (e.g., ListOfStatus).

   • Set the Condition to:

     Identifier = Id

     • This will filter the list to only include the item that matches the given Identifier.

3. After the ListFilter, add an Assign widget to update the output:

   • Set ListOfStatus (our function output) = ListFilter.FilteredList

💡 Now the function works for both cases:

• If no Identifier is provided, it returns the full list.

• If an Identifier is provided, it returns only the matching item, instead of all labels.

🧠 Step 6 – Using seStatus (and other functions) in the app

Let’s say we want to display a list of activities with their Status, Priority, and Cluster.

1. Create a Block where we will handle the data.

2. Inside the block, create a Data Action.

   • Note: I already created some records in ActivityNew. Others can create their own records as needed.

3. After creating the Data Action, drag an Aggregate into the flow:

   • Select ActivityNew as the source.

   • 

4. Set the output of the Data Action:

   • Data type: Text Record List

   • Add attributes to the output for the values we want to expose:

     Name, Status, Priority, Cluster

     • All of them set as Text.

     • 

5. Next, drag an Assign widget:

   • Set the output of the Data Action = Aggregate results.

   • Now you will be prompted to map each record attribute:

     • Name → ActivityNew.Name

     • Status →seCluster(ActivityNew.ClustersId).Current.Label  <---see how we used our function 

     • Priority → sePriority(ActivityNew.PriorityId).Current.Label

     • Cluster → seCluster(ActivityNew.ClusterId).Current.Label

   • 

💡 This way, the block will return a list of activities with all the necessary values in text format, fully replacing the need for Static Entities.

Now just drag a Table to the block and assign the Output List 

Use the block to a screan and PUBLISH AND let s see the result 

🧠 Step 7 – Observing the results and bonus usage

After running the app, you can see the results in the interface:

• Where Priority is missing, it means that either the Identifier was not set or it was left empty.

• I did this intentionally to show that the function works correctly and handles missing values gracefully.

💡 Bonus: LET me teach you how to filter by multiple choises

The function can also return a full list if no specific Identifier is passed.

• This is useful when you want to populate dropdowns or lookup values without filtering for a single item.

• Additionally, you can filter directly in an aggregate using multiple values in the filter, which allows you to dynamically retrieve only the relevant subset of records while still using our server functions.

This demonstrates the flexibility of the approach:

1. Single-item lookup using an Identifier.

2. Full list retrieval when no Identifier is provided.

3. Optional filtering at the aggregate level for more complex scenarios.

🧠 Step 8 – Creating a reusable Data Action for Filters / Dropdowns

In the block, we will create another Data Action, called Filter/Dropdowns:

• The purpose of this Data Action is dual:

  1. To populate dropdowns.

  2. To provide a filtered list when needed.

• For the output, set the name as you like (e.g., List) and set the data type to List of strStaticEntity.

Flow setup:

1. Drag an Assign widget into the flow.

2. Assign the output (List) to the result of our server function.

   • Example:

     List = seStatus()

   • Notice we don’t pass any Identifier here, so the function will return the full list.

   • 

   • 

💡 This pattern works the same for other static-like data:

• sePriority() → returns all priorities

• seCluster() → returns all clusters

This allows you to re-use the same Data Action for multiple dropdowns or filtering scenarios without creating multiple static entities.

Ok now For the Bonus Let me show you how to filter in aggregate for multiple filter

Get The String_Jon in action from manage dependencies

Create a variable called StatusFilter or whatever you want(we gonna store here our multiple ids for filtering) 

Go to our aggregate in the data action 

add this filter 

I am using DropdownSearch but you can use also DropdownTags, but make sure that the allow multiple choise is set tot true

Bring String_Join action to the DropdownSearchOnchanged Action and set the list input to be selectedoption list from the exxpresion editor and add "," as separator

Assign Variable StatusFilters to be = to the output of the stringJoin action, then refresh the data action that get our activities and THAT IS ALL, let` s test it!!!

As you can see it s working for single choise 

But Also For Multiple 

Thank you All and feel free to reply with your thoughts or improvements!