OutSystems Associate Developer key terms

A user interface page in an OutSystems app that holds widgets, input parameters, and local variables. Web Screens render in a browser; Mobile Screens render in a native mobile app shell.

A reusable interface element dragged onto a Screen, such as a Button, Input, Table, or Container. Widgets expose properties that control appearance and behavior without writing code.

A reusable group of widgets and logic that can be placed on multiple Screens. Blocks have their own scope, inputs, and events, so they help avoid duplicating interface pieces.

A reusable unit of server-side logic built from a flow of statements, such as assignments, queries, and calls to other actions. Server Actions run on the server; Client Actions run in the browser or device.

Logic that executes on the OutSystems server, typically used for data access, validation, and business rules. It can call other server actions and aggregates but cannot directly manipulate the browser DOM.

Logic that runs in the user's browser or on the mobile device, used for interface behavior such as validating input or toggling visibility. It can use local variables and call server actions.

A visual query that reads data from one or more Entities, applying filters, sorting, and grouping without writing SQL. Aggregates are used in screens and actions to fetch records efficiently.

A data model definition representing a table of records with attributes and relationships. Entities are created in the data layer and map to database tables in the environment.

A single field or property defined on an Entity, such as a name or date. Each attribute has a data type and may be mandatory or have a default value.

An Entity whose records are defined at design time rather than created by users at runtime, such as a list of statuses or categories. Its records are deployed with the app.

The ordered set of events a Screen goes through, including Initialize, Preparation, Render, and Destroy. Developers attach logic to these events to load data and set up the interface.

A screen event that runs before the screen renders, commonly used to run Aggregates and prepare data for display. It runs on the server for web screens.

A value passed into a Screen, Block, or Action when it is called. Input parameters let the same logic or interface be reused with different data.

A value returned by an Action or Block to its caller. Output parameters carry results such as a success flag or a fetched record back to the calling context.

A value stored for the duration of a user's login session and accessible across screens and actions. Session variables are useful for holding the current user or selected context.

A configurable value defined at the application level and settable per environment without redeploying code. Site properties commonly hold settings such as API endpoints or feature flags.

A named permission grouping assigned to users to control access to screens and server actions. Roles are checked at runtime to decide whether a user may perform an operation.

A screen designed for a native mobile app, rendered by the OutSystems mobile runtime rather than a browser. It supports mobile-specific patterns such as gestures and native plugins.

The mechanism that stores data locally on a mobile device and synchronizes it with the server when connectivity is available. It lets users work without a network connection.

On-device storage used by mobile apps to keep data available without a network connection. OutSystems mobile apps use local entities and client variables to persist such data.

A value held on the client side, such as in the browser or on the mobile device, for the duration of the session or app run. Client variables are read and written by client actions.

A packaged capability that gives a mobile app access to device features such as the camera, GPS, or contacts. Plugins are added to the app and called from client actions.

The native container that hosts an OutSystems mobile app on the device and provides navigation, lifecycle, and access to device APIs. It is generated when the mobile app is built.

OutSystems Developer Cloud, a cloud-native development platform where apps, data, and deployment are managed as services. It uses a studio in the browser and separates build, deploy, and runtime concerns.

The browser-based development environment used to build apps in OutSystems Developer Cloud. It provides the editor for screens, logic, data, and app configuration.

The top-level container in OutSystems that groups related modules, such as a web app and its supporting libraries. Apps are versioned and deployed together as a unit.

A unit of development inside an App that contains screens, actions, entities, and other elements. Modules can be reused by other modules through references and public elements.

A dependency that lets one Module use public elements, such as actions or entities, exposed by another Module. References are resolved when the app is built and deployed.

An action, entity, or other element marked as exposed so that other Modules can reference and use it. Only public elements are visible outside their defining module.

The process of publishing an app version to an environment so users can access it. In ODC, deployment moves an app through stages and makes the new version live.

A step in the ODC delivery pipeline, such as development, test, or production, through which an app version progresses. Each stage maps to an isolated runtime environment.

An isolated runtime where a deployed app executes, with its own database and configuration. Separate environments keep development, testing, and production data apart.

An action exposed as a REST or SOAP endpoint so external systems can call it. Service actions define the API contract and are consumed by integrations.

Connecting an app to external systems or services, often through REST APIs or connectors. Integrations let apps consume or expose data beyond their own database.

A set of style rules and variables that control the look of an app's screens and widgets. Themes centralize colors, fonts, and spacing so appearance stays consistent.

Checks that ensure user input meets rules such as required fields, ranges, or formats before data is saved. Validations can run on the client for feedback and on the server for safety.

The four basic data operations: Create, Read, Update, and Delete. Simple apps typically provide screens and actions that let users perform each of these on an Entity.

A screen that displays multiple records, usually from an Aggregate, in a repeating widget such as a list or table. It often links to a detail screen for a selected record.

A screen that shows or edits a single record, typically receiving the record identifier as an input parameter. It is commonly reached from a list screen.

The practice of catching and responding to errors in logic flows so the app fails gracefully. OutSystems provides exception handlers that run when an error occurs in an action.