I85PREP
⌘ K
OutSystems Professional Developer study materials
OutSystems Professional Developer study resources

OutSystems Professional Developer practice questions

One question at a time. Build your OutSystems Professional Developer understanding.

First 50 of 200 questions. Each one lists the choices, the correct answer, and an explanation. The checker at the top of this page saves progress in this browser when it is available.

Continue in the practice tool above to load more questions, 50 at a time.

Question 1Architecture

In the OutSystems architecture, which layer is responsible for storing persistent business data and is accessed by the server-side logic rather than directly by the browser?

  1. The presentation layer
  2. The theme layer
  3. The client-side JavaScript layer
  4. The database layer Correct answer.

Explanation

OutSystems applications follow a layered model where the database layer holds persistent entities and is reached only through server-side logic such as server actions and aggregates. The browser never talks to the database directly; it communicates with the server tier.

Question 2Architecture

In a traditional OutSystems web application, where does screen preparation logic (such as the Preparation action) execute?

  1. Inside the database as a stored procedure
  2. In the browser, after the HTML is delivered
  3. On the server, before the screen is rendered Correct answer.
  4. In a separate mobile offline cache

Explanation

A screen's Preparation runs on the server tier as part of rendering the screen, loading data through aggregates and server actions before HTML reaches the client. This keeps data access and business rules on the server.

Question 3Architecture

Which OutSystems module type is intended to expose reusable server-side business logic and entities to other modules without providing a user interface?

  1. A module containing only theme and style elements
  2. A module containing only client-side JavaScript widgets
  3. A module containing only screen and UI flow elements
  4. A module containing only server-side elements such as actions and entities Correct answer.

Explanation

Reusable back-end logic and data are packaged in modules that expose server actions and entities, letting other modules reference them. UI concerns are kept in separate modules so the logic can be reused across channels.

Question 4Architecture

What is the primary purpose of a Producer module in an OutSystems application architecture?

  1. To host only the end-user screens of one channel
  2. To store deployment configuration for the environment
  3. To expose reusable elements that Consumer modules reference Correct answer.
  4. To consume services published by other modules

Explanation

A Producer module publishes reusable elements, such as actions, entities, and structures, that other modules consume. Consumers reference those exposed elements rather than duplicating logic.

Question 5Architecture

Which statement best describes how the OutSystems platform separates the development model from the deployed runtime?

  1. The model runs exclusively inside the database engine
  2. The visual model is compiled and generated into deployable application artifacts Correct answer.
  3. The model is stored only as documentation and manually reimplemented
  4. The model is interpreted directly by the browser at runtime

Explanation

OutSystems is a model-driven platform: developers build a visual model, and the platform generates and compiles the corresponding application artifacts for deployment. The runtime executes generated code, not the raw model.

Question 6Architecture

In OutSystems, what does an Entity represent within the application architecture?

  1. A deployment environment setting
  2. A client-side event handler
  3. A reusable screen template for a channel
  4. A persistent data model element mapped to a database table Correct answer.

Explanation

Entities model persistent business data and are backed by database tables managed by the platform. Their attributes become columns, and relationships between entities become foreign keys.

Question 7Architecture

Which OutSystems element is used to fetch and aggregate data from the database for display on a screen?

  1. A session variable
  2. A client action
  3. A theme
  4. An aggregate Correct answer.

Explanation

Aggregates query entities and combine data on the server, producing a result set that screens and logic can use. They are the standard way to retrieve persistent data.

Question 8Architecture

What is the role of a Site Property in an OutSystems module's architecture?

  1. It schedules a background job
  2. It defines a persistent entity attribute
  3. It stores a configurable value that can differ per environment without redeploying logic Correct answer.
  4. It renders a reusable UI block

Explanation

Site Properties hold configuration values that can be set differently in each environment, such as endpoints or feature flags, so the same module can adapt without code changes. They are configuration, not data model or UI.

Question 9Architecture

A team wants a mobile app and a web app to share the same business rules and entities. Which architectural approach best fits OutSystems?

  1. Duplicate the entities and logic in each channel app
  2. Put the shared logic in each screen's preparation action
  3. Put the shared logic only in the mobile app and call it from web
  4. Place shared logic and entities in a producer module referenced by both channel apps Correct answer.

Explanation

Sharing business logic and data through a producer module keeps a single source of truth that both channel apps consume. Duplication creates divergence and maintenance risk.

Question 10Architecture

When a Consumer module references an Entity exposed by a Producer module, what does the Consumer actually work with?

  1. A private copy of the entity's table
  2. A reference to the Producer's public entity definition Correct answer.
  3. A cached snapshot refreshed only at deployment
  4. A read-only view with no relationships

Explanation

Consumers reference the public definition exposed by the Producer, so changes to the Producer's public contract propagate. The Consumer does not own a separate copy of the table.

Question 11Architecture

Why should server-side business logic avoid being placed directly in screen actions when it must be reused by multiple screens?

  1. Screen actions always run in the browser and cannot call the server
  2. Screen actions cannot access entities
  3. Screen actions are deleted at each deployment
  4. Screen actions are tied to a screen context and are not the right place for shared rules Correct answer.

Explanation

Logic embedded in a screen action is bound to that screen and cannot be cleanly reused, so shared rules belong in server actions or a producer module. This keeps a single source of truth and simplifies testing.

Question 12Architecture

An architect needs a background process that periodically reconciles data without user interaction. Which OutSystems element provides this capability?

  1. A Block rendered inside a screen
  2. A Client Action triggered by a button
  3. A Timer that runs a server action on a schedule Correct answer.
  4. A Screen Preparation that runs on page load

Explanation

Timers execute server-side logic on a defined schedule, making them suitable for periodic reconciliation independent of user activity. Screen preparations and client actions depend on user interaction.

Question 13Architecture

What is the architectural effect of exposing an entity as public in a Producer module?

  1. The entity is copied into every Consumer module
  2. The entity can no longer be modified by the Producer
  3. The entity's data becomes readable by anonymous web users automatically
  4. Other modules can reference the entity and its public attributes Correct answer.

Explanation

Making an entity public allows Consumer modules to reference it and use its exposed attributes and relationships. It does not grant anonymous access or copy the entity, and the Producer retains ownership.

Question 14Architecture

A developer places a large aggregate in a screen's Preparation that returns thousands of rows for a list. What architectural concern does this raise?

  1. Improved security because all rows are loaded server-side
  2. Inefficient server load and slow rendering because data is fetched without paging Correct answer.
  3. Better mobile offline support because rows are preloaded
  4. Reduced database usage because aggregates cache results

Explanation

Fetching large result sets in Preparation increases server work and delays rendering; list screens should use paging or fetch only what is needed. Aggregates do not automatically cache results or provide offline support.

Question 15Architecture

Which OutSystems concept allows a module to call logic published by another module while keeping the two loosely coupled?

  1. A duplicated copy of the action in each module
  2. A public server action exposed by a Producer and referenced by a Consumer Correct answer.
  3. A shared session variable between the two modules
  4. A global client variable declared in both modules

Explanation

Exposing a server action publicly and referencing it from a Consumer keeps a defined contract between modules, so the Producer can evolve internally without breaking consumers. Shared variables and duplication create hidden coupling.

Question 16Architecture

In an OutSystems architecture, what distinguishes a Server Action from a Client Action?

  1. Both run only during deployment
  2. Server actions run in the browser, while client actions run on the server
  3. Server actions run on the server tier, while client actions run in the browser Correct answer.
  4. Both run only in the database engine

Explanation

Server actions execute on the server and can safely access entities and sensitive logic, while client actions execute in the browser for UI interactivity. This split is central to where logic should live.

Question 17Architecture

A team must integrate with an external REST API whose endpoint differs between development and production. Which architectural practice best supports this?

  1. Hard-code the production endpoint in the server action
  2. Create a separate module for each environment
  3. Store the endpoint in a Site Property configured per environment Correct answer.
  4. Embed the endpoint in each screen's preparation

Explanation

Site Properties externalize environment-specific configuration so the same module can point to different endpoints per environment without code changes. Hard-coding or duplicating modules undermines portability.

Question 18Architecture

Which statement about the OutSystems deployment model is accurate for moving an application between environments?

  1. Applications are deployed as compiled artifacts promoted through environments Correct answer.
  2. The database is exported and imported without application artifacts
  3. Source files are copied manually and recompiled by hand
  4. Each environment rebuilds the model from scratch without deployment packages

Explanation

The platform compiles the model into deployable artifacts that are promoted across environments, keeping behavior consistent. Manual copying or environment-specific rebuilds are not the platform's deployment approach.

Question 19Architecture

What is the architectural benefit of using a UI Flow to separate a public area from an authenticated area in a web app?

  1. It automatically encrypts all data in transit
  2. It groups screens with distinct access rules and entry points Correct answer.
  3. It replaces the need for server actions
  4. It stores persistent entities for each area

Explanation

UI Flows organize screens into logical groups, such as public and authenticated areas, each with its own entry point and access considerations. They do not store data or replace server logic.

Question 20Architecture

A Consumer module needs data from a Producer entity but only a subset of attributes. What is the sound architectural approach?

  1. Query the Producer's database table directly with raw SQL
  2. Copy the entire entity into the Consumer
  3. Expose only the needed attributes publicly and reference the entity Correct answer.
  4. Make every attribute public to avoid future changes

Explanation

Exposing only the required attributes keeps the public contract minimal and reduces coupling, while still allowing the Consumer to reference the entity. Over-exposing or copying creates unnecessary dependencies.

Question 21Architecture

An architect observes that two Producer modules both expose an entity with the same name and structure. What is the main architectural risk of Consumers referencing both?

  1. Automatic synchronization of the two entities
  2. Stronger security because access is duplicated
  3. Ambiguity and divergence because the same concept is owned in two places Correct answer.
  4. Improved performance because queries are split

Explanation

Two owners of the same concept create ambiguity about which definition is authoritative and risk divergence over time. A single owning module should define the entity to preserve a clear source of truth.

Question 22Architecture

Why is placing sensitive authorization checks in a Client Action considered an architectural flaw?

  1. Client actions cannot read session variables
  2. Client actions cannot call server actions
  3. Client actions execute only during deployment
  4. Client actions run in the browser, where checks can be bypassed, so enforcement must be server-side Correct answer.

Explanation

Because client actions execute in the browser, a determined user can bypass or alter them, so authorization must be enforced on the server where it cannot be tampered with. Client-side checks are for experience, not security.

Question 23Architecture

A system must remain responsive while a long-running data import executes. Which architectural choice best fits OutSystems?

  1. Run the import in a Timer or asynchronous server-side process and update status separately Correct answer.
  2. Run the import synchronously inside the screen's Preparation
  3. Run the import inside a Block's render event
  4. Run the import in a Client Action loop

Explanation

Long-running work should be moved off the user request path into a Timer or asynchronous server process, with status tracked separately. Running it synchronously in Preparation or the browser blocks the user and risks timeouts.

Question 24Architecture

An architect wants to enforce that all writes to a core entity pass through a single set of validation rules. Which design best achieves this?

  1. Rely on database constraints alone for all business validation
  2. Allow each Consumer to write to the entity directly with its own validation
  3. Centralize create and update logic in server actions owned by the Producer module Correct answer.
  4. Validate only in the screen's client-side logic

Explanation

Routing writes through centralized server actions in the owning module ensures consistent validation regardless of which consumer initiates the change. Distributed or client-only validation lets rules drift and be bypassed.

Question 25Architecture

In an OutSystems architecture, which element is the recommended place to store a value that must be readable by all users of a module but changed only by administrators at runtime?

  1. A Site Property configured with a default value and editable in Service Center Correct answer.
  2. A Local Variable declared in the module's global scope
  3. A Session Variable populated during login
  4. An Input Parameter on every public Screen Action

Explanation

Site Properties are module-level configuration values stored outside the code, so they can be changed per environment without a new deployment. They are readable anywhere in the module and are the standard mechanism for runtime-tunable settings.

Question 26Architecture

A module exposes a Server Action to other modules. What must the architect do for a Consumer module to be able to call it?

  1. Mark the Server Action as Function and add it to the Consumer's UI Flow
  2. Set the Server Action's property to Public and reference the Producer module as a dependency Correct answer.
  3. Convert the Server Action into a Client Action so it can be shared
  4. Publish the Server Action to the Service Center's global actions list

Explanation

Cross-module reuse in OutSystems requires the element to be exposed as Public in the Producer and a dependency reference from the Consumer. Once the reference exists, the action appears in the Consumer's scope.

Question 27Architecture

Which statement correctly describes the relationship between a UI Flow and a Screen in a Reactive Web application?

  1. A UI Flow groups screens and their navigation, and each Screen belongs to exactly one UI Flow Correct answer.
  2. A Screen defines its own UI Flow automatically when it is created from a template
  3. A UI Flow is a runtime container created per user session that hosts screens dynamically
  4. A Screen may belong to several UI Flows simultaneously to allow reuse of its layout

Explanation

UI Flows are design-time containers that organize screens and define the navigation graph between them. A screen is placed in one UI Flow, and moving between flows requires an explicit navigation element.

Question 28Architecture

An architect is reviewing a module and finds that a Screen's Preparation fetches data used only after the user clicks a button. Which change best reflects sound OutSystems architecture?

  1. Keep it in Preparation but wrap it in a Client Action
  2. Move the fetch into the module's OnApplicationReady event
  3. Split the screen into two screens that each load the data
  4. Move that data fetch into the Screen Action triggered by the button Correct answer.

Explanation

Preparation should load only what the screen needs to render initially; deferring work to the action that actually needs it avoids unnecessary queries on every screen load. This keeps screen rendering fast and the data flow explicit.

Question 29Architecture

Two modules need to exchange a structured record that is not persisted in the database. Which OutSystems element is designed for this purpose?

  1. A Structure exposed as Public by the Producer module Correct answer.
  2. An Entity exposed as Public with Read Only set
  3. A Session Variable of type Record shared between modules
  4. A Static Entity exposed with a record per attribute

Explanation

Structures are in-memory composite types intended for passing grouped values between actions and modules without persistence. Exposing the Structure as Public lets Consumers use the same definition.

Question 30Architecture

A Consumer module calls a Producer Server Action that raises an unhandled exception. What is the architectural consequence in the Consumer?

  1. The Producer automatically retries the action until it succeeds
  2. The exception propagates to the Consumer's calling action, which can handle it with an Exception Handler Correct answer.
  3. The Consumer's module is aborted and the user session is terminated
  4. The exception is silently swallowed and the Consumer continues with empty output

Explanation

Exceptions raised in a Producer action flow back to the caller, so the Consumer can decide how to handle them. This allows each Consumer to apply its own error policy without the Producer dictating it.

Question 31Architecture

Why does OutSystems recommend keeping business rules in Server Actions of a core module rather than in Screen Actions of the UI module?

  1. Server Actions can be reused by multiple screens and modules and are enforced regardless of the client Correct answer.
  2. Server Actions can access the database while Screen Actions cannot
  3. Screen Actions cannot call other modules' public actions
  4. Screen Actions execute faster than Server Actions because they avoid the network

Explanation

Centralizing rules in server-side logic means every caller, including future channels, goes through the same validation. Screen Actions are tied to a single screen and can be bypassed or duplicated.

Question 32Architecture

An application must send an email whenever an order is created, and orders can be created from a web screen, a mobile app, and a REST API. Which architectural placement best avoids duplicated logic?

  1. A Client Action in each channel that sends the email after the order is submitted
  2. A database trigger configured on the order entity
  3. A Server Action in the orders core module that all three entry points call after creating the order Correct answer.
  4. A JavaScript snippet embedded in each screen that triggers the email service

Explanation

Placing the notification in a reusable Server Action of the core module ensures every channel follows the same path. Each entry point simply calls the shared action, so the rule cannot drift between channels.

Question 33Architecture

What is the primary architectural purpose of a Timer in an OutSystems module?

  1. To delay the rendering of a screen until data is ready
  2. To run server-side logic on a schedule without a user request Correct answer.
  3. To retry failed Client Actions automatically
  4. To throttle calls to an external REST API during peak load

Explanation

Timers are scheduled server-side processes that wake up on a defined cadence and run their action flow in the background. They are the standard choice for periodic reconciliation, cleanup, or batch work.

Question 34Architecture

A Producer module exposes an Entity as Public. A Consumer uses it in an Aggregate. What is the Consumer actually reading?

  1. The physical database table owned by the Producer module, filtered through the exposed definition Correct answer.
  2. A read-only view generated in the Consumer's own database schema
  3. A cached copy of the entity data replicated into the Consumer module at publish time
  4. A web service call issued to the Producer for each row requested

Explanation

Entities are logical mappings over physical tables, and a public reference lets the Consumer query the same underlying table. No data is copied into the Consumer module at deployment.

Question 35Architecture

An architect must decide how to call an external REST service whose base URL changes between environments. Which approach fits OutSystems architecture best?

  1. Create a separate REST integration for each environment inside the module
  2. Store the base URL in a Site Property and reference it from the REST integration Correct answer.
  3. Hardcode the production URL and edit it manually before each deployment
  4. Pass the base URL as an Input Parameter to every action that calls the service

Explanation

Environment-specific configuration belongs in Site Properties so the same module can be deployed unchanged across environments. The integration reads the value at runtime.

Question 36Architecture

A team plans to expose an Entity publicly so another module can read it, but the Consumer only needs three of its twelve attributes. Which design decision is most appropriate?

  1. Expose the full Entity and add a database view for the three attributes
  2. Expose the Entity and let the Consumer use only the needed attributes in its Aggregates Correct answer.
  3. Create a duplicate Entity in the Consumer module with only the three attributes
  4. Expose the Entity as a Structure containing the three attributes instead

Explanation

Exposing the entity once and selecting the required attributes in the Consumer's aggregates keeps a single source of truth without duplicating the model. Attribute selection is a query concern, not a reason to fork the entity.

Question 37Architecture

An architect notices that a public Server Action in a core module is being called directly from Screen Actions in five different UI modules. What risk does this pattern introduce?

  1. The action will execute more slowly because it is called from multiple modules
  2. The public action will be automatically converted into a Client Action
  3. Changes to the action's signature force republishing and potentially updating all dependent modules Correct answer.
  4. The core module will lose its ability to reference the UI modules

Explanation

A widely referenced public action becomes a contract: changing its inputs or outputs ripples to every Consumer. This is a normal trade-off of reuse, but it means the signature must be designed carefully and changed deliberately.

Question 38Architecture

Which statement best explains why OutSystems separates the module's data model into Entities rather than allowing direct SQL against arbitrary tables?

  1. Entities remove the need for database indexes and tuning
  2. Entities prevent developers from writing any SQL in the application
  3. Entities give the platform a declarative model it can validate, deploy, and evolve across environments Correct answer.
  4. Entities guarantee that queries always return a single row

Explanation

Declaring entities lets the platform generate and manage the physical schema, track dependencies, and apply changes during deployment. This keeps the model consistent across environments.

Question 39Architecture

A screen in a Reactive Web app must show a list that refreshes after the user saves a record on the same screen. Which mechanism is the standard way to reload the aggregate?

  1. Call the aggregate's Refresh action inside the Screen Action after the save succeeds Correct answer.
  2. Reload the entire browser page with a JavaScript location.reload call
  3. Move the aggregate into the module's OnApplicationReady event
  4. Re-run the Preparation by navigating to the same screen with a new URL

Explanation

Aggregates expose a Refresh action that re-executes the query and updates the bound widgets without a full page reload. Calling it after a successful save keeps the UI in sync with minimal disruption.

Question 40Architecture

An architect is choosing between a single large module and several smaller modules for a new application. Which consideration most strongly favors splitting into multiple modules?

  1. Reduced total number of elements in the application
  2. Guaranteed performance improvement from smaller module size
  3. Elimination of the need for public element exposure
  4. Independent deployability and clearer ownership boundaries between teams Correct answer.

Explanation

Splitting into modules lets teams deploy and evolve parts of the system independently while exposing only deliberate contracts. This is the main architectural driver for modularization.

Question 41Web Development

In OutSystems, which element is used to display a list of records in a Reactive Web App while automatically handling pagination and empty states?

  1. Table
  2. Form
  3. List Records Correct answer.
  4. If widget

Explanation

The List Records widget is the standard container for iterating over a record list in Reactive Web screens, and it renders built-in empty-state messages and supports pagination patterns. It binds directly to a List variable or aggregate result and repeats its inner content per record.

Question 42Web Development

Which OutSystems screen lifecycle action runs on the server before the screen is rendered and is the correct place to execute aggregates that feed the screen?

  1. OnParametersChanged
  2. OnReady
  3. OnRender
  4. OnInitialize Correct answer.

Explanation

OnInitialize executes on the server before rendering and is where screen aggregates are typically run to populate the screen's data. OnReady runs on the client after rendering, so it is too late for server-side data preparation.

Question 43Web Development

A developer needs to expose a REST endpoint from an OutSystems module so external systems can retrieve customer data. Which element should be created?

  1. Timer that pushes data
  2. Client Action with public scope
  3. Server Action exposed as a Service Action Correct answer.
  4. Screen with an anonymous role

Explanation

Exposing a REST API in OutSystems is done by creating a Server Action and marking it as a Service Action, then consuming it through the module's exposed REST interface. Client Actions run in the browser and cannot serve as backend endpoints.

Question 44Web Development

When building a Reactive Web App, which mechanism is recommended for passing data from a parent block to a child block?

  1. Local storage
  2. Global client variables
  3. Input parameters on the block Correct answer.
  4. Session variables

Explanation

Blocks communicate through input parameters, which create an explicit, typed contract between parent and child and enable the platform to track dependencies for re-rendering. Session and global variables create hidden coupling and are harder to test.

Question 45Web Development

Which OutSystems entity attribute setting ensures that a value is required before a record can be saved?

  1. Set the attribute's Is Mandatory property to Yes Correct answer.
  2. Set the attribute's data type to Text
  3. Mark the attribute as a Foreign Key
  4. Set the attribute's Default Value

Explanation

The Is Mandatory property on an entity attribute enforces that a value must be supplied when a record is created or updated. Default values and data types do not enforce presence of a value.

Question 46Web Development

A developer wants an aggregate to return only the top 10 records ordered by creation date descending. Which aggregate property should be configured?

  1. Set the aggregate's Cache property to 10
  2. Add a Filter on Created On and set the aggregate's Timeout to 10
  3. Set the aggregate's Fetch property to Only One
  4. Max Records set to 10 with a Sort on Created On descending Correct answer.

Explanation

The Max Records property limits how many rows the aggregate returns, and the Sort property determines which rows are kept when combined with that limit. Setting Sort to Created On descending with Max Records 10 yields the ten most recent records.

Question 47Web Development

Which OutSystems role model element determines whether a user can access a screen?

  1. The screen's Description property
  2. The module's Is Public property
  3. The screen's Check Roles property referencing roles Correct answer.
  4. The screen's Title property

Explanation

Screen access in OutSystems is controlled through the Check Roles property, which lists the roles permitted to open the screen. Users without any of the listed roles are denied access at runtime.

Question 48Web Development

In OutSystems 11, which built-in flow tool is used to redirect the user to another screen while passing input parameters?

  1. Navigate
  2. Destination Correct answer.
  3. Show Feedback Message
  4. Notify

Explanation

The Destination tool redirects the action flow to another screen. Its configuration lets the developer supply values for the target screen's input parameters, allowing the receiving screen to use the passed data. In OutSystems 11, Destination is the documented flow tool for this navigation.

Question 49Web Development

A Reactive Web screen needs to react immediately to a user typing in a search box and filter a list. Which mechanism best supports this behavior?

  1. A screen variable bound to the input with the aggregate's filter using that variable Correct answer.
  2. A Timer that re-runs the aggregate every second
  3. A scheduled job that refreshes the list
  4. A server action invoked from the OnRender event

Explanation

In Reactive Web, binding an input widget to a screen variable and referencing that variable in an aggregate filter causes the aggregate to re-run automatically when the variable changes. This provides live filtering without polling.

Question 50Web Development

Which OutSystems construct is used to group reusable UI and logic that can be embedded in multiple screens and expose input parameters?

  1. Block Correct answer.
  2. Entity
  3. Server Action
  4. Timer

Explanation

A Block is a reusable UI component that can be dropped into screens and other blocks and exposes input parameters and events. It encapsulates its own screen logic and layout.