The Connector Pattern, a type of Library Module, serves as a dedicated wrapper for integrating with an external system. Its primary responsibility is to encapsulate all technical aspects of the connection, such as API methods (e.g., REST/SOAP), data structures, and authentication logic. This pattern isolates the complexities of the external system, translating its data and operations into a format that can be easily consumed within the OutSystems platform. This is achieved by either consuming a service definition or using Integration Studio to inspect an external database or library, thereby creating a clear and reusable integration point.

A. This describes a synchronization pattern with notifications (webhooks), which is a specific implementation built on top of a connector, not the connector pattern itself.

B. This describes a "no local cache" data access strategy, focusing on the runtime behavior of an integration rather than the structural pattern of the connector module.

C. This describes the "Sync Wrapper" pattern, where synchronization logic is isolated from the core service, which is a pattern related to data replication.

D. This describes the "Hybrid" or "Partial Cache" data synchronization pattern, where only a subset of data is stored locally.

E. This describes the "Core Service" or "Entity Core Service" (ECS) pattern, which is about encapsulating business entities and logic, not external system integration.

G. This describes an "Aggregation" or "Federation" pattern, which abstracts multiple data sources, a more complex pattern than a basic connector.

H. This describes the "Lazy Load" or "Read-Through Cache" data synchronization pattern, where data is cached on demand.

I. This describes the "Integration Wrapper" pattern, which involves two modules (a Connector and a Core Service Wrapper). The question asks specifically for the Connector pattern.

J. This describes the "Local Replica" or "Full Cache" data synchronization pattern, where external data is fully replicated in local entities.

1. OutSystems Official Documentation

"Designing the architecture of your OutSystems applications

" Section: Core Modules.

This section defines a Connector as a specific type of Library module that "wraps an external system

like a database or a web service. It contains all the necessary elements to connect to the external system

such as Integration logic

data Structures

and authentication." This directly supports the description in option F.

2. OutSystems Official Documentation

"Integration with External Systems

" Section: Isolate integration logic in Connectors.

This guide states

"Create a dedicated module

a Connector

to isolate the communication details. This module contains the consumed services

structures

and logic to handle authentication and logging." This reinforces that a connector's role is to encapsulate and wrap the technical integration details

as described in option F.

The Foundation layer, according to the OutSystems Architecture Canvas, is designed to contain the core, non-functional building blocks of an application portfolio. Its primary data elements are the Core Entities, which represent the fundamental business concepts (e.g., Customer, Product). A critical best practice is to expose these entities as read-only (Expose Read Only = Yes) to enforce the use of public wrapper actions (CRUD actions) that contain business logic and validation, thus ensuring data integrity and encapsulation.

A. CRUD actions for Entities: These are server actions, which are logic elements, not data elements. While they are correctly placed in a Foundation module, they are not the data element itself.

C. Non-core Entities: Non-core entities are specific to a business process or a single application and should be placed in Core or End-User layers to avoid bloating the Foundation layer.

D. Entities to save UI states: These entities are directly tied to the user interface and belong in the End-User layer to prevent incorrect dependencies from a stable foundation to a volatile UI layer.

1. OutSystems - Official Documentation

"The 4 Layer Canvas": Under the "Foundation Layer" section

it states: "They usually implement the data model by defining the Core Entities... and provide all the necessary core services to handle data

like Create

Read

Update

and Delete actions (CRUD wrappers)." This distinguishes entities as the data model and actions as services.

2. OutSystems - Official Documentation

"Designing the architecture of your OutSystems applications"

Section: "Isolate core services in Foundation modules": This guide explicitly states

"A Foundation module should define a data model with Core Entities." It further recommends: "To enforce this

set the Entities' Public property to No

or expose them as read-only by setting the Expose Read Only property to Yes." This directly supports the correct answer.

3. OutSystems - Official Documentation

"Architecture Dashboard"

Section: "Code analysis patterns"

Finding: "Incorrectly Placed Entity (IE)": This documentation explains the violation that occurs when an entity is not in the correct layer. It reinforces that core business concepts belong in Foundation modules

while entities specific to application logic or UI belong in Core or End-User modules

respectively.

The official OutSystems Architecture Design Process is a structured, three-step methodology for creating a sound application architecture. The steps are:

1. Disclose: Identify the key business concepts from requirements.

2. Organize: Classify the identified concepts into types (e.g., core, library).

3. Assemble: Draft the modules and define the relationships and dependencies between them.

"Plan" is a general activity in software development but is not one of the three formally defined steps of this specific OutSystems architectural process.

A. Organize: This is the second step of the process, where identified concepts are classified to prepare for module creation.

C. Assemble: This is the third and final step, where the actual modules and their relationships are designed and drafted.

D. Disclose: This is the first step of the process, which involves discovering and listing the main business concepts.

1. OutSystems Official Documentation

"Designing the architecture of your OutSystems applications

" Section: A 3-step process to design an architecture. This document explicitly outlines the "Disclose

" "Organize

" and "Assemble" steps as the core of the design process. It does not mention "Plan" as a formal step.

2. OutSystems Official Documentation

"Designing the architecture of your OutSystems applications

" Section: Step 1: Disclose - identify the concepts. This section details the first step of the process.

3. OutSystems Official Documentation

"Designing the architecture of your OutSystems applications

" Section: Step 2: Organize - classify concepts by type. This section details the second step of the process.

4. OutSystems Official Documentation

"Designing the architecture of your OutSystems applications

" Section: Step 3: Assemble - draft the modules and their relationships. This section details the third step of the process.

In OutSystems 11 a dependency is considered weak only when the consumer doesn’t compile any executable code that must call the producer at runtime. Elements that are used solely for design-time metadata (e.g., Static Entities, Structures, Screens used only as type definitions) can therefore become weak dependencies. Referencing any executable Action, however, forces Service Studio to generate a direct runtime call, which always creates a strong dependency. Server Actions are executable code units that run on the server; consequently they can never be tagged as weak dependencies. Hence option C (Server Actions) is the only element in the list that is not eligible to become a weak dependency in OS11.

A. Screens – If no Navigate-To or entry reference exists, the dependency is only design-time and becomes weak.

B. Static Entities – Used merely as literal values, they compile into constants and the reference is weak.

D. Database Entities – When used only for type definition (e.g., StructureFromEntity), dependency is weak.

E. Service Actions – Behave like Server Actions but may be referenced only for default output structure, allowing weak dependency when not invoked.

F. Local Storage Entities – Similar to database entities; type-only usage leads to weak dependency.

G. Structures – Purely design-time type information; if no records are instantiated, dependency is weak.

1. OutSystems Documentation v11

“Dependencies: Weak vs. Strong Dependencies”

paras 3-4 (docs.outsystems.com/11).

2. OutSystems 11 Service Studio

Help > Manage Dependencies Window

table “Elements that always create strong dependencies”

note on Actions (build version 11.14).

3. OutSystems Training – Development Fundamentals

Module “Decoupling Architecture”

slide 12 “Actions always create strong dependencies” (Training portal course ID DF-110).

4. OutSystems Architecture Guideline eBook v11

section 4.2 “Weak References”

pg 27-28 (OutSystems Engineers

2019).

In the context of OutSystems architecture, the term "OAPI" is likely used to refer to the internal Application Programming Interface of an OutSystems module, specifically a Service Module. The core component of this interface, used to expose reusable, non-breaking business logic and functionality to other modules within the same environment, is the Service Action. This provides a strongly-typed, compile-time-checked contract between modules. This is distinct from a REST API, which is a technology used to expose functionality over web standards (HTTP) primarily for external systems or decoupled front-ends.

B. REST API: A REST API is a specific type of web service interface for exposing functionality, not a component inside the fundamental, internal API of a Service Module. A REST API method typically calls a Server Action to execute its logic.

1. OutSystems Official Documentation

"Service Actions": "A Service Action is a public Server Action in a Service Module. It encapsulates a piece of business or integration logic and can be reused across different modules... Service Actions are the key element for building a service-oriented architecture." This source establishes the Service Action as the key element of a Service Module's reusable API.

2. OutSystems Official Documentation

"Designing the architecture of your applications"

The 4 Layer Canvas: In the section describing Core Services

it states: "They offer reusable business services... exposing a well-defined and non-breaking public API of Service Actions." This reinforces that the API of a Core Service module is composed of Service Actions.

3. OutSystems Official Documentation

"Expose REST APIs": "Expose REST APIs to make your application's data and functionality available to other systems." This document defines REST APIs as a mechanism for external exposure

distinguishing them from the internal

module-to-module communication facilitated by Service Actions.