OutSystems Professional Developer study plan

Map the OutSystems platform layers (development environment, deployment controller, platform database, runtime) and write a one-page diagram of how a module travels from Development to Production.

Differentiate OutSystems entity types (server, client, static, external) and list at least two valid use cases for each.

Explain the purpose of the deployment controller and lifecycle stages, then describe what happens to a module's compiled state between staging and production.

Identify the three default roles (Developer, Administrator, End User) and state which environment-level permissions each holds.

Distinguish module types (Reactive Web, Traditional Web, Mobile, Service, Extension) and justify a module type choice for three given business scenarios.

Describe the purpose of producer/consumer module references and list two rules that prevent circular dependencies.

Configure a solution with two modules, publish it to a personal environment, and verify the deployment log shows successful compilation and dependency resolution.

Explain how IT-oriented settings (e.g., Application Lifetime, session timeout) affect runtime behavior and where they are configured.

Build a Reactive Web screen with a data-bound list, a form for create/edit, and client-side validation on required fields.

Implement a screen action that calls a server action, handles the success and error paths, and shows an inline feedback message.

Apply the correct use of Aggregates versus SQL queries, including when a SQL query is justified and how to parameterize it safely.

Configure authentication flow (login, logout, session expiry redirect) and confirm an unauthenticated user is redirected to the login screen.

Model a normalized entity model of at least four entities with relationships and expose it through a server action layer.

Implement exception handling using the built-in Exception Handler flow and log errors to a custom entity.

Apply role-based screen access and verify that a user lacking a role sees the correct fallback behavior rather than an error.

Optimize one slow aggregate by reducing fetched attributes and adding a filter, then record before-and-after response behavior.

Build a Mobile app screen with a list-detail pattern using local storage entities and describe when local storage is appropriate versus server data.

Implement offline behavior: cache data locally, detect connectivity, and show a queued-sync message when offline.

Configure the mobile app's authentication and session handling, including what happens to local data on logout.

Use the device capabilities plugin (e.g., camera or geolocation) in a screen action and handle permission denial gracefully.

Explain the Mobile app build and distribution pipeline (native shell generation, signing, distribution to stores or enterprise) and list the steps a developer must complete.

Structure a screen using Blocks and reusable UI patterns, and refactor one repeated UI element into a reusable Block.

Apply responsive layout rules using the grid and container behaviors so a screen renders correctly at phone, tablet, and desktop widths.

Implement client-side state and screen lifecycle events (OnInitialize, OnReady, OnRender) and explain the order in which they fire.

Apply OutSystems UI patterns and theme customization to restyle a screen without inline styles, and document which CSS variables were overridden.

Implement client-side and server-side input validation together and demonstrate that server-side validation rejects a tampered request.

Harden the app against the OWASP-style risks relevant to OutSystems: enforce role checks in server actions, avoid exposing sensitive data to the client, and parameterize SQL.

Configure a secure authenticated REST API call from the client, including where credentials should and should not live.

Consolidate weak areas by re-testing every domain with a timed practice set and recording per-domain accuracy.

Rebuild one end-to-end feature (entity, server action, screen, role check, validation) from scratch without reference material to confirm retention.

Review deployment and lifecycle questions again, since architecture concepts are commonly tested in scenario form.

Write a one-page personal cheat sheet of the ten facts you most often got wrong.