OutSystems Architecture-Specialist-11 - Architecture Specialist (OutSystems 11) Exam

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

Architecture Dashboard allows you to automatically apply a solution to solve a found code pattern.

Architecture Dashboard performs a code analysis that uncovers patterns related to performance, security, architecture and maintainability.

M_CS

_CS

mobile_CS

m_cs

m_CS

Sync only when required. p At session start: sync summary data to local storage At process start: sync process detail to local storage At process/transaction end, sync back to server

Only synchronize delta : Use control timestamps

C Avoid long synchronization in a single transaction

Sync only when strictly required

E Don't sync on every screen or online event

Only synchronize relevant data

Do not use Entity Bulk Operation to ensure small lightweight updates

Ensure sync granularity: Prepare for constant retries without repeating work due to network loss. Sync in chunks, incremental by entity

... 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 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)

... 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

... is needed if data is coming from MULTIPLE external systems. IS will decide which driver to use depending on the data.

... 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)

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

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

... 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

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

Above is the answer

Optimizes lifecycle independence

Promotes microservices

Minimizes impact of changes

Promotes abstraction of reusable services

Stop unmanageable dependencies

Prevent slow deployments, inflexible legacy systems

Avoid poor service abstraction

User Experience Expectations

Integration Technology

User Stories, Personas and Roles

Architecture Canvas Modules

Information Architecture