Every component can carry several actions. An action has a trigger, the condition that fires it; an execution, the thing it does; and an outcome, what changes on the screen, in the data or in the flow.
A trigger is a condition on the component or on the screen: a button clicked, a value entered and valid, a row selected, a dropdown changed, a screen loaded, a file uploaded, a barcode scanned, a clock reached. Triggers can carry a criterion, so a grid's row-selected trigger fires only for rows in a certain status, and a field's value-changed trigger fires only when the new value is outside a range.
Triggers keep the screen honest: an approve button that enables only when the note has ten characters and the claim is covered is two triggers with two outcomes, and the person sees the button light up as the conditions are met.
| Trigger | Fires when | Example criterion |
|---|---|---|
| on click | a button or link is pressed | txt_note.value.length > 10 |
| on change | a field, dropdown or checkbox changes | dd_decision.value == 'split' |
| on valid | a field passes its validation | txt_serial matches the serial pattern |
| on select | a grid row or list item is selected | grd_claims.selected.status == 'in warranty' |
| on load | the screen opens for a role | sys.role == 'assessor' |
| on upload / scan / sign | a file, code or signature is captured | up_photos.count >= 1 |
| on clock | a step's clock reaches a point | clock.remaining < 1h |
Written in the editor; scripts and REST calls where a formula is too small.
| Execution | Does | Example |
|---|---|---|
| Set a value | Writes a property of a component or a variable | app.claim_total = grd_claims.selected.estimate |
| Call a data handler | Reads, updates, saves or deletes rows through a handler | dh_po.update(line, confirmed_date = dt_new.value) |
| Run a function | Calls a named function of the platform or one you registered | check_coverage(serial, fault_date) |
| Run a script | Executes a script for logic beyond a formula | python: allocate(open_orders, stock) |
| Call a REST endpoint | Calls an external service and maps the answer | screening(legal_entity) → risk_class |
| Move the flow | Starts an instance, completes the step, starts a clock, notifies | complete_step('decide'); notify(role.buyer_lead) |
Executions run with the identity of the person acting and the app's own grants, so a handler write goes through the source's released interface under the same access rules as any other write. Long executions, such as a script over many rows, run in the background and the outcome fires when they return; the screen shows the state meanwhile.
Every execution is logged with its inputs and its result, so the decision log can show that btn_approve called the ERP change interface with these values and received this document number.
An outcome is the visible result: a panel fills, a component enables or hides, a grid refreshes, a value is saved, a row is written back, a notification goes out, a clock starts, the flow moves to the next node. An action can have several outcomes, and outcomes can trigger other components' actions, which is how a screen stays consistent: select a row, and the detail, the chart and the buttons all follow.
Outcomes are also where the platform enforces its own rules. A write-back outcome waits for the acknowledgement before it reports success; a flow outcome checks the arrow's criterion before it moves; an outcome that would violate a validation rule reports the message and stops.
Criteria, calculations, validations, triggers and outcomes are all expressions in one language: fields by handler and column, components by ID and property, variables by scope and name, functions by name, with the usual operators, dates, text and lists. The editor completes names as you type and evaluates the expression for a row you pick from the handler, so a threshold, a date rule or a text pattern is checked against a real record before it is saved.
For a start criterion the editor shows the count of rows selected and a sample; for a validation it shows the message the person would see; for an action it runs the trigger and the execution in a sandbox and shows the outcome. A reference to a field the handler lacks, or a type mismatch, is flagged in place.
# trigger criterion of the late purchase order app, tested on live rows select dh_po_lines where delivery_date <= today + 5 and received_qty < qty → 31 rows · sample: 4500012345/00010 · EINDT 2026-09-18 · 0 of 1,200 received # coverage decision on the warranty screen if dh_warranty.warranty_end >= dt_fault.value and dd_fault_type.value in dh_warranty.covered_types and num_estimate.value < glob.claim_band then 'covered' else 'assess' → 'covered' for serial CX4-0921 · band 500
Screen variables hold a filter or a draft value and vanish when the screen closes. App variables hold what an instance has decided so far: the claim total, the chosen site, the current level, and they travel from node to node through the variable exchange properties. Global variables are defined once for the platform and carry meaning for every app: the fiscal calendar, the plant list, the approval bands. System variables are provided by the platform: today's date, the time, the logged-in user and role, the number of users online.
Variables have a definition screen with types, defaults and a test, so a global approval band can be checked against a sample amount before any app uses it. Changing a global variable is logged and versioned like any other change.
| Scope | Lives | Defined | Example |
|---|---|---|---|
| Screen | while the screen is open | on the screen | scr.filter_plant |
| App | while the instance runs | on the app | app.claim_total, app.level |
| Global | always; shared by all apps | on the platform | glob.claim_band = 500 |
| System | always; provided | by the platform | sys.today, sys.user, sys.role |
Formulas cover almost everything: conditions, calculations, dates, text, lists. Scripts and REST calls are there for the remaining cases, and an application team usually writes those once as functions the business configurators then call by name.
Yes, through a REST call with the platform's secrets vault holding the credentials; the answer is mapped to variables and the call is logged.
Writes go through data handlers and released interfaces, under the acting person's access rules; a write-back reports success only on acknowledgement; validations stop invalid outcomes; and every execution is logged with its inputs and result.
Actions on a component travel with the component when it is copied, and a set of actions can be saved as a named function.
Bring one process and the systems it touches. In the first session we register the data handlers, draw the levels or the lanes and run the first screen on your live rows.