Free Practice Questions for the OutSystems Architecture Specialization Architecture-Specialist-11 Exam (2026 Updated)

Transparency Service Pattern 1 way (simplification)

Library : Extension Pattern

ECS with isolated synchronization logic

ECS Lazy Load variation

ECS with publish/subscribe through an ESB

ECS Summary cache only variation

Library : Connector Pattern

M_CS

_CS

mobile_CS

m_cs

m_CS

CRUD actions for Entities

Core Entities (exposed as read-only)

Non-core Entities

Entities to save UI states

Compatibility : Compatibility was also added as a way to ensure that a piece of software can work together with other systems

Security : Security ensure software solutions can protect information and data

Integration : Integration to allow data exchange with other software

Service Action

REST API

Promotes segregation and loose coupling of services

Optimizes lifecycle independence

Promotes abstraction of reusable services

Minimizes impact of changes

Is the end result of Architecture Design Process. At this point you should add dependencies between the Modules.

Above is the answer

Adopt the correct sync frequency: Either at process start and online or at process/transaction end and online

Sync on every screen or online event

Sync data required per use case: Sync summary data on Session start. On data selection, sync p its details.

Example: if you are accessing Purchasing data, sync the summary data on Session start. On selecting the Purchasing item, sync the details of the Purchasing item such as photos or price, a

Concepts are disclosed to the Architecture team

Concepts are assembled into Modules

Concepts are added to the layers of the Architecture Canvas

Store password in local storage

Encrypt (only) sensitive data

Authentication : Use google or facebook for online authentication or fingerprint or pin for offline authentication

Non-core Entities

Entities to save UI states

Core Entities (exposed as read-only)

CRUD actions for Entities

MyApp_CS Module, in the Foundation layer

MyApp_BL, in the Foundation Layer.

MyApp_Th Module, in the End-User layer

MyApp_MTh, in the Foundation layer.

The " specialize a built-in Style Guide " scenario should be used when the changes to the base theme are not extensive.

The " clone a built-in Style Guide " should be used when you want to extend an existing theme.

Build-your-own Style Guide should be used when the changes in the theme are not extensive.

Layer Applications Correctly

Don ' t Mix Sponsers : Split the Apps based on the Lines of Business

Layer Entities Correctly

Layer Modules Correctly

Don ' t Mix Owners

Common modules and services should be isolated in a separate app that can be referenced by other apps.

Owners of the Application should not be mixed, but mixing Sponsors has no direct impact on the release.

If you follow all the rules for validating modules, your application composition will be sound, and easy to maintain and deploy.

Applications in the Foundation layer can reference Applications in the End-user layer.

Poor service abstraction

Unmanageable dependencies

Manages complexity

Slow-moving legacy systems

framework to support Architecture Conventions for Modules in Outsystems

framework to support application architecture design in Outsystems

framework to support Architecture Design Process in Outsystems

... caches only summary data that is frequently lister, joined or searched. Full detail for a single entry is fetched directly from external system. Use when whole database too big or costly to synchronize. Details are only required for single entities (not lists)

... is a pattern with two modules, a connector module that can be used to encapsulate an external API with the input/output structures and a wrapper module to expose the normalized API to the consumers.

Same as Base ECS pattern, but have a local replica. Store data to serve as a local cache. Pro: Leverage Entity Use, Simpler Integration API. Con: Less impact on source system

... Entity is exposed as read-only and API is available to centralize business logic for entity creation/update

... tries to fetch data from local cache entity, if not there, get single entry from the external system. Cache only that record (read-through caching) Use when whole database too big or costly to synchronize. Integration only touches a small portion of the database. Avoid if access to lists of data is needed up front

Same as ECS with local replica but API module is provided. So any changes to the external system can notify OS, which OS then gets update from the ERP system (subscription system)

Same as ECS with local replica but synchronization logic is separated. Pro: Code independence. Consumers of CS is not affected by Sync. Sync can orchestrate several CS

Keep concepts with different lifecycles apart.

Join all integrations into a single Module.

Disclose business concepts and integration needs.

Isolate all business concepts.

Customer_CW

Mobile_API

Service_CS

Pricing_MBL

Poor service abstraction

Reduces costs

Reduces risk

Supports planning