Free OutSystems Associate Developer Exam Flashcards

The visual IDE where developers design screens, model data, build logic flows, and configure integrations. It is the primary development tool for both O11 Reactive Web Apps and ODC applications.

It is the real-time integrity engine that continuously analyzes your module as you edit. It highlights errors, warnings, and broken references immediately without waiting for compilation, catching many issues at design time.

It compiles the current module, runs TrueChange checks, and deploys it to the connected development environment. It does NOT deploy to production — cross-environment promotion is handled separately through LifeTime.

It creates OutSystems Extensions — wrappers around .NET or Java libraries exposed as OutSystems actions. Use it when you need to call native code, proprietary SDKs, or system-level functionality not available natively in Service Studio.

A community marketplace of reusable components — widgets, connectors, templates, and accelerators shared by OutSystems and the community. Install Forge components to add functionality like charting, maps, or payment integration without building from scratch.

ODC (OutSystems Developer Cloud) is cloud-native, built on Kubernetes with microservices and container isolation. O11 is the traditional module-based platform. They have different runtime models and are not directly compatible — O11 modules cannot be automatically migrated to ODC.

The runtime monitoring console for viewing logs, errors, and managing running modules in a specific environment. It is an operations tool, not a development IDE.

It is the deployment management and governance platform for promoting applications between environments (Development, QA, Production). It handles versioning, deployment plans, and environment management — not app development.

An Entity represents a database table with typed attributes. Each entity has an Identifier (auto-increment primary key) and can store persistent records. Entities are the foundation for data modeling and are queried via Aggregates or SQL.

A Static Entity has its records defined at design time and deployed with the app, functioning as an enumeration or lookup table. Use it for fixed-value sets like Status (Active, Inactive), Priority (Low, Medium, High), or Category types. Records are accessed via strongly typed identifiers.

Use dot notation: EntityName.RecordName. For example, Status.Active references the Active record identifier from the Status Static Entity. This provides compile-time type safety and avoids hardcoded integer IDs or magic strings.

Add a foreign key attribute of the parent Entity Identifier type to the child entity. For example, add CustomerId (type Customer Identifier) to the Order entity. OutSystems creates the database FK constraint and index automatically.

Create a join entity with foreign key attributes to both related entities. For Student and Course, create a StudentCourse join entity with StudentId and CourseId. Queries then join through the join entity in Aggregates.

A visual query builder that retrieves data from one or more entities. It supports joins, filters, sorting, computed attributes, and max record limits — all without writing SQL. Aggregates run server-side and return typed record lists.

It limits how many rows the query returns (equivalent to a SQL TOP/LIMIT clause). Set it to the page size for paginated lists or to a reasonable cap to avoid loading thousands of rows unnecessarily, improving performance.

Use Decimal. It maps to DECIMAL/NUMERIC in the database and avoids floating-point precision errors. Never use Float for money — floating point cannot exactly represent values like 0.1. OutSystems has no dedicated Currency type.

It controls what happens to child records when a parent is deleted. Protect (default) blocks parent deletion if children exist. Delete cascades the deletion to children. Ignore sets the FK to null. Choose based on your data integrity requirements.

It fires before the screen renders, during the initial load. Use it to set default values for local variables and prepare the screen state before the UI is displayed to the user.

It fires once after the screen has finished rendering and the DOM is ready for user interaction. Use it for logic that should run after the UI is fully displayed, such as triggering initial data loads or setting focus.

It fires when the screen is already displayed and receives new input parameters — for example, navigating to the same detail screen with a different record ID. Use it to refresh screen data without a full re-initialization.

It conditionally renders one of two branches (True or False) based on a boolean condition evaluated in the browser. Only the matching branch appears in the DOM. It is the primary mechanism for conditional UI rendering.

Bind the List widget's Source property to a list of records — typically the output of a Data Action containing an Aggregate. The List widget repeats its content for each record, and you map individual fields to widgets inside the list item.

Set the Mandatory property to True on an Input widget inside a Form. The platform automatically validates the field before submission and displays an error message if empty. The Form's Valid property aggregates all field validation states — no manual JavaScript needed.

Use the Navigate action inside a Client Action (typically triggered by a button or link OnClick). Specify the destination screen and map values to its input parameters. OutSystems generates the URL and handles typed parameter passing automatically.

A variable that exists only in the client-side scope of that screen instance. It is initialized fresh on each navigation and is not persisted to the database or shared between sessions. Use it for temporary UI state like form values, toggles, or selected items.

Client Variables persist their values across screen navigations within the same browser session (similar to session storage). Local Variables are reset on each navigation. Use Client Variables for multi-step form state or user preferences; they are lost when the browser tab closes.

A reusable UI fragment (formerly WebBlock) with its own data, logic, local variables, and events. Blocks accept input parameters and can raise events to communicate with parent screens. Embed them in multiple screens to reuse UI patterns like headers, cards, or form sections.

An action that executes on the server. It can run Aggregates, execute SQL queries, call external APIs, and perform business logic. Server Actions cannot directly manipulate browser UI elements but return data to the calling client.

An action that runs in the browser as JavaScript. It can manipulate local variables, access UI elements, and trigger navigation. It cannot directly execute Aggregates or SQL — to fetch data it calls a Server Action or Data Action.

A server-executed action attached to a screen or block specifically for fetching data to populate that UI component. It supports caching (cache in minutes), runs during the screen data-loading phase, and returns typed data bindable directly to widgets. Use it as the standard pattern for screen data loading.

A block that catches exceptions raised within the action — either from a Raise Exception node or system errors like database failures. The handler can log the error, set an output variable, or re-raise. It is the OutSystems equivalent of try/catch.

It explicitly throws an exception during action execution, causing the flow to jump to the nearest matching Exception Handler. Use it to validate business rules and abort execution when conditions are not met, such as invalid input or unauthorized access.

A scheduled background Server Action that runs automatically at configured intervals (e.g., nightly at 2 AM). Use it for batch operations like sending notifications, purging old data, or syncing with external systems. Timers run server-side and asynchronously.

The User Identifier of the currently authenticated user. Available in both Server Actions and Client Actions. Commonly used in Aggregate filters to scope data per user (e.g., filter orders where UserId equals GetUserId()).

It returns the empty/uninitialized value for an Entity Identifier type. Use it to check if a variable represents a new record (if Id equals NullIdentifier then create, else update) and to signal create-new behavior when passed to CreateOrUpdate.

It performs an upsert: if the record's identifier is NullIdentifier, it inserts a new record and returns the new ID. If the identifier has a value, it updates the existing record. This is the standard pattern for save operations in forms.

Use the REST API Consume wizard in Service Studio's Integrations tab. Paste the API URL or import a Swagger/OpenAPI definition. OutSystems generates strongly typed Server Actions for each endpoint, handling serialization, authentication headers, and typed response objects automatically.

A named configuration value stored per environment in Service Center. The same module can have different Site Property values in Development, QA, and Production (e.g., an API endpoint URL or feature flag). Code reads values at runtime, making the app environment-aware without code changes or redeployment.

A design-time compile dependency declared in Service Studio that lets one module use public elements (Server Actions, Entities, Blocks) from another module. Once referenced, the consuming module can call the producer's public elements. Keep references minimal to avoid tight coupling.

Set the Server Action's Public property to Yes in Service Studio. By default all elements are private. Setting Public allows other modules that reference this module (via Manage Dependencies) to call the action, though it executes in the producer module's context.

Set breakpoints in Server Actions, Data Actions, and logic flows. When execution hits a breakpoint it pauses, letting you inspect variable values, entity records, and step through the action logic line by line. It is the primary tool for diagnosing runtime logic errors.

Set the Input widget's Variable property to a local variable. The variable's current value is displayed in the input, and when the user changes the value, the variable is automatically updated — no manual event listeners needed. This is declarative two-way binding.

It creates a database-level DEFAULT constraint on the column. If a record is created without explicitly setting that attribute, the database assigns the default value automatically. This ensures data integrity at the database level, independent of UI logic.

Create a reusable Server Action containing the shared validation logic and call it from every action that needs it. This follows the DRY principle and ensures consistent behavior. The reusable action can live in the same module or a referenced Core module.

A Module is the atomic building block containing screens, entities, actions, and integrations. An Application is a deployment unit that groups related modules. A common pattern: one UI module, one Core module, and one API module under a single Application.

Elements (Server Actions, Entities, Blocks, Structures) with their Public property set to Yes. These are visible to and usable by other modules that declare a reference via Manage Dependencies. By default, all elements are private to their module.

Roles are defined at the application level and assigned to users. Screens, Server Actions, and Entities can specify which roles are required to access them. Users without the required role are denied access. This provides declarative authorization without manual permission checks in logic.

Reactive Web Apps run client-side with JavaScript rendering and use Client Actions, Data Actions, and screen lifecycle events. Traditional Web Apps use server-side rendering with screen preparation logic. Reactive is the modern default for new OutSystems applications.

Isolated containers in OutSystems Developer Cloud where apps run independently with their own scaling. Each app in ODC is a self-contained unit deployed to a zone, unlike O11 where modules share a runtime. This provides better isolation and independent scaling per app.

Use LifeTime to create a deployment plan that promotes the application (with its modules) between environments. LifeTime manages versioning, tracks dependencies, and applies the deployment in the target environment. 1-Click Publish only deploys to the development environment — never directly to production.