Here’s a comprehensive 100-point guide on what you must know to train and teach OutSystems, focusing on AI and low-code development. I’ve organized it into categories for clarity: Foundations, OutSystems Platform, Low-Code Best Practices, AI Integration, Security & Governance, Deployment & DevOps, Advanced Features, Teaching & Training Tips.
Understand the concept of low-code development.
Explain the benefits of low-code: speed, agility, less coding.
Understand how OutSystems fits into enterprise development.
Know the difference between low-code and no-code.
Explain visual development and drag-and-drop interfaces.
Teach how to model business processes visually.
Explain database-first vs. logic-first approaches.
Understand responsive design principles in low-code apps.
Introduce learners to application lifecycle management in low-code.
Discuss common use cases: internal apps, dashboards, mobile apps.
Explain integration patterns with external systems.
Teach learners how low-code supports rapid prototyping.
Discuss limitations and when full code may be required.
Explain Agile methodology in low-code projects.
Show examples of enterprise apps built in OutSystems.
Navigate the OutSystems Service Studio IDE.
Understand modules, applications, and solutions.
Create a new web or mobile application.
Explain entities, attributes, and data modeling.
Create and manage screens using visual editors.
Use UI templates and themes.
Implement business logic with actions and flows.
Create server-side logic using visual logic flows.
Understand client-side logic and mobile gestures.
Manage data using aggregates and queries.
Explain the OutSystems database architecture.
Use built-in widgets effectively.
Implement screen navigation and workflows.
Publish applications to development and testing environments.
Use Service Center for monitoring apps and logs.
Teach modular app design for reuse.
Explain separation of concerns (UI, logic, data).
Promote naming conventions for entities and actions.
Implement consistent UX and design patterns.
Encourage error handling and validation flows.
Teach debugging techniques in Service Studio.
Use comments and documentation for maintainability.
Encourage peer review of logic flows.
Implement scalability patterns.
Teach performance optimization for queries and logic.
Introduce AI/ML capabilities within OutSystems.
Teach integration with AI services like OpenAI or Azure AI.
Explain when to use AI-assisted features vs. manual logic.
Implement AI chatbots using integrations.
Show how to use AI for data predictions.
Teach use of AI for text summarization or NLP.
Explain AI model endpoints and REST API integration.
Demonstrate calling AI models from OutSystems actions.
Teach how to process AI responses in apps.
Implement AI-based automation workflows.
Show error handling for AI service calls.
Teach logging and monitoring AI interactions.
Discuss ethical considerations for AI in apps.
Demonstrate AI-powered analytics dashboards.
Teach testing AI-based features in apps.
Explain authentication and authorization in OutSystems.
Implement role-based access control.
Secure sensitive data using encryption.
Teach secure API integrations.
Implement input validation to prevent security risks.
Explain GDPR and data privacy considerations.
Use auditing and logging in Service Center.
Monitor app performance and security alerts.
Implement session management and MFA for apps.
Teach secure development lifecycle practices.
Teach publishing to different environments: Dev, QA, Prod.
Explain the OutSystems LifeTime management console.
Show automated deployments and CI/CD pipelines.
Teach version control for OutSystems modules.
Implement environment-specific configuration.
Monitor deployment logs and errors.
Manage dependencies between modules.
Teach rollback strategies for failed deployments.
Explain performance monitoring after deployment.
Teach automated testing and integration with QA tools.
Use timers and scheduled processes.
Implement custom REST and SOAP integrations.
Teach working with external databases.
Show how to use web services and APIs.
Implement push notifications in mobile apps.
Use local storage and offline capabilities in mobile apps.
Teach advanced data visualization techniques.
Implement reusable components and libraries.
Show integration with external authentication providers.
Teach debugging complex workflows and logic chains.
Start with foundational concepts before platform details.
Use hands-on exercises and mini-projects.
Demonstrate step-by-step app creation.
Encourage learners to replicate examples independently.
Include quizzes and knowledge checks after each topic.
Teach troubleshooting and debugging practices.
Provide real-world scenarios for problem-solving.
Encourage pair programming or collaboration.
Use short, digestible lessons with visual examples.
Integrate AI examples for relevance and engagement.
Teach learners to document their projects.
Encourage experimentation with widgets and logic flows.
Use gamification to reinforce learning.
Monitor learner progress and provide feedback.
Update content regularly to reflect new OutSystems features and AI integrations.
Here’s a 12-week structured training roadmap for teaching OutSystems AI Low-Code Development. It’s designed for learners to progress from foundational concepts to advanced AI integrations, including hands-on labs, exercises, and assessments.
Objectives: Understand low-code development concepts and OutSystems environment.
Topics:
What is low-code vs. traditional coding
Benefits and limitations of low-code
Overview of OutSystems platform: Service Studio, LifeTime, Service Center
Types of apps: Web, Mobile, Reactive, Traditional
Labs & Exercises:
Navigate Service Studio
Create a simple “Hello World” web app
Assessment:
Quiz on low-code concepts and OutSystems components
Objectives: Learn to design and manage data structures in OutSystems
Topics:
Entities, attributes, and relationships
Data types and constraints
Aggregates and queries
Best practices for data modeling
Labs & Exercises:
Create entities for a sample HR app
Build basic queries to fetch data
Assessment:
Mini-project: Employee directory app with searchable data
Objectives: Build responsive UIs with reusable components
Topics:
Screen templates, themes, and layouts
Widgets and controls
Navigation patterns
UX best practices
Labs & Exercises:
Create multi-screen app with navigation and responsive layout
Assessment:
Peer review of UI design for usability and consistency
Objectives: Implement server-side and client-side logic visually
Topics:
Actions, flows, and logic elements
Client vs. server actions
Using local and session variables
Error handling and validation
Labs & Exercises:
Build a workflow to calculate employee leave balances
Assessment:
Test app logic with sample data
Objectives: Connect OutSystems apps to external systems
Topics:
REST and SOAP integrations
Consuming external APIs
Handling authentication and headers
Mapping response data to entities
Labs & Exercises:
Connect to a public API (e.g., weather or finance data)
Assessment:
Mini-project: App displaying live API data
Objectives: Implement user access and security best practices
Topics:
Role-based access control (RBAC)
Multi-factor authentication (MFA)
Input validation and secure data handling
GDPR compliance principles
Labs & Exercises:
Create admin and user roles
Implement login and MFA workflow
Assessment:
Test role-based access scenarios
Objectives: Introduce AI/ML concepts and integration in OutSystems
Topics:
Overview of AI/ML use cases
Integrating AI via REST APIs
Examples: sentiment analysis, predictions, text summarization
Ethical considerations in AI
Labs & Exercises:
Connect to an AI API (OpenAI or Azure AI)
Display predictions or responses in the app
Assessment:
Demonstrate AI-powered feature in a test app
Objectives: Implement intelligent workflows and chatbots
Topics:
AI-driven automation workflows
Text classification, natural language processing (NLP)
Handling AI responses in logic flows
Logging and monitoring AI calls
Labs & Exercises:
Build a chatbot with AI API integration
Assessment:
Mini-project: AI chatbot answering FAQs
Objectives: Learn OutSystems mobile capabilities
Topics:
Native vs. reactive mobile apps
Offline storage and synchronization
Push notifications
Mobile gestures and responsive design
Labs & Exercises:
Build a mobile app with offline data sync
Assessment:
Peer testing on different devices
Objectives: Deploy apps and monitor performance
Topics:
Environments: Dev, QA, Prod
LifeTime console for deployment
CI/CD basics
Performance monitoring and error logging
Labs & Exercises:
Deploy an app to QA environment
Monitor logs in Service Center
Assessment:
Deployment checklist validation
Objectives: Optimize apps and prepare for production
Topics:
Modular app design and reusability
Performance optimization (aggregates, queries, logic)
Debugging complex workflows
Documentation and maintainability
Labs & Exercises:
Refactor a sample app for performance
Implement reusable components
Assessment:
Code review exercise
Objectives: Apply all concepts learned in a real-world project
Project:
Build a complete app integrating:
User authentication & MFA
Role-based access
Database backend
External API integration
AI-powered feature (chatbot, prediction, or analytics)
Responsive UI for web and mobile
Labs & Exercises:
Present app to peers or instructor
Peer and instructor review for feedback
Assessment:
Final project grading and knowledge review
Quiz covering all 12 weeks
Hands-on first: Labs and exercises every week
Progressive learning: From basics → integration → AI → deployment
Real-world relevance: AI, mobile, API, and security use cases
Assessments: Quizzes, mini-projects, capstone project
Teaching tips: Peer review, documentation, and feedback integration
Module 1 of the OutSystems AI Low-Code Development Training. This module corresponds to Week 1: Introduction to Low-Code & OutSystems Platform. I’ll structure it with learning objectives, key concepts, explanations, examples, hands-on exercises, and assessment questions—everything needed to teach or learn the module.
By the end of this module, learners will be able to:
Explain what low-code development is and its benefits.
Differentiate between low-code and no-code platforms.
Describe OutSystems platform components (Service Studio, LifeTime, Service Center).
Identify different types of apps that can be built using OutSystems.
Navigate the OutSystems interface and create a simple application.
Low-code allows creating applications visually with minimal manual coding.
Benefits:
Rapid development and deployment
Easier collaboration between developers and business users
Reduces dependency on full-time coding experts
Low-code platforms can accelerate prototyping and enterprise app delivery.
Feature
Low-Code
No-Code
Target Users
Developers & business users
Non-technical users
Customization
High
Limited
Coding Required
Minimal
None
Use Cases
Complex apps, integrations
Simple forms, workflows
Service Studio: Visual IDE to design apps, workflows, and logic.
LifeTime: Application lifecycle management console for environment management.
Service Center: Monitoring tool for apps, logs, and performance metrics.
Web Applications: Desktop-first or responsive web apps.
Mobile Applications: Native or reactive mobile apps for iOS/Android.
Reactive Web Apps: Hybrid apps with a dynamic, responsive interface.
Traditional Web Apps: Classic server-rendered apps for enterprise systems.
Internal dashboards and portals
Employee management apps
Customer support apps
AI-assisted chatbots and analytics dashboards
Sign in to your OutSystems personal environment.
Open Service Studio (desktop or web version).
Familiarize yourself with the main panels: Interface, Logic, Data, Toolbox.
Click New Application → Web App → From Scratch.
Enter App Name: HelloWorldApp.
Select a theme/template (e.g., OutSystems UI Default).
Create a home screen and add a Label widget with text: “Hello World!”.
Click 1-Click Publish to deploy the app.
Open the app in a browser to test it.
Modules: Building blocks of apps.
Entities: Tables storing data.
Attributes: Columns in tables.
Actions: Visual logic that handles app behavior.
Exercise 1: Navigate Service Studio and explore all panels.
Exercise 2: Create a new web app named MyFirstApp.
Exercise 3: Add a label, button, and input field.
Exercise 4: Publish your app and test in the browser.
Exercise 5: Change the theme and style of your app using OutSystems UI.
Example 1: Simple dashboard with labels displaying user information.
Example 2: Web form collecting user input (name, email) and showing it back on the screen.
Example 3: “Hello AI” example connecting to a dummy REST API returning a greeting (preparation for AI integration).
What are the advantages of using low-code development over traditional coding?
Can low-code platforms handle complex enterprise applications? Why or why not?
How does OutSystems support both web and mobile applications?
How does Service Studio differ from LifeTime and Service Center?
Multiple Choice Questions:
Which OutSystems component is used to design apps visually?
a) LifeTime
b) Service Studio ✅
c) Service Center
d) Integration Builder
Low-code platforms are best described as:
a) Platforms for non-technical users only
b) Platforms with no coding required
c) Platforms for rapid development with minimal coding ✅
d) Platforms for database administration only
Which app type is best for mobile-first dynamic interfaces?
a) Traditional Web App
b) Reactive Web App ✅
c) Desktop App
d) Command-line App
What is the primary purpose of LifeTime?
a) Designing visual workflows
b) Managing app deployment and lifecycle ✅
c) Monitoring user logs
d) Writing code
Practical Task:
Create a “Hello World” web app in Service Studio and publish it. Screenshot your working app as evidence.
OutSystems Official Documentation: https://success.outsystems.com/Documentation
OutSystems Guided Paths: “Introduction to OutSystems”
Video Tutorials: OutSystems Academy YouTube channel
Sample Apps: Explore OutSystems Forge for beginner apps
This module is fully self-contained and ready for training, including theory, step-by-step instructions, exercises, examples, discussion, and assessment.
Module 2 of the OutSystems AI Low-Code Development Training, corresponding to Week 2: Data Modeling & Database Basics. This module is fully structured with learning objectives, key concepts, step-by-step instructions, exercises, examples, discussion questions, and assessments.
By the end of this module, learners will be able to:
Explain data modeling concepts and their importance in low-code applications.
Create and manage entities and attributes in OutSystems.
Design relationships between entities (one-to-one, one-to-many, many-to-many).
Implement business rules and validation at the data level.
Use aggregates and queries to retrieve and display data in apps.
Entities = tables storing data (e.g., Employee, Product).
Attributes = columns in tables (e.g., Name, Email, Salary).
Primary Key = unique identifier for each record (Id).
Data Types: Text, Integer, Decimal, Boolean, Date/Time, Identifier.
Type
Description
Example
One-to-One
Each record in Entity A maps to one record in Entity B
Employee → EmployeeDetail
One-to-Many
One record in Entity A maps to multiple records in Entity B
Department → Employees
Many-to-Many
Multiple records in Entity A map to multiple in Entity B (junction table)
Students ↔ Courses
Validation: Ensure data integrity (e.g., email format, salary > 0).
Mandatory fields: Required attributes.
Default values: Pre-fill attributes when creating records.
Aggregate: Visual tool in OutSystems to retrieve and filter data.
Filters: Conditions applied to retrieve subsets of data.
Sorting & Grouping: Order data for display or reporting.
Advanced Queries: SQL queries for complex data retrieval.
Use meaningful names for entities and attributes.
Normalize data to reduce duplication.
Use indexes on frequently queried attributes for performance.
Avoid storing sensitive data without encryption.
Document data model and relationships.
Open Service Studio.
Go to the Data tab → Entities.
Click Add Entity → Name it Employee.
Add attributes: Name (Text), Email (Text), HireDate (Date/Time), Salary (Decimal).
Set Email as mandatory.
Add another entity: Department with attributes: DepartmentName (Text).
Create a One-to-Many relationship: Department → Employees.
Add an attribute DepartmentId in Employee as Foreign Key.
Configure delete behavior (e.g., restrict, cascade).
Go to a screen → Add an Aggregate.
Select the Employee entity.
Add filters: e.g., Salary > 50000.
Sort by HireDate descending.
Bind the aggregate to a Table widget to display results.
Use Advanced SQL if aggregate cannot handle the requirement.
Example: SELECT e.Name, e.Email, d.DepartmentName FROM Employee e JOIN Department d ON e.DepartmentId = d.Id WHERE e.Salary > 50000.
Exercise 1: Create entities: Customer, Order, Product.
Exercise 2: Define relationships: Customer → Orders (One-to-Many), Orders → Products (Many-to-Many with junction entity OrderItem).
Exercise 3: Add business rules: Order Quantity > 0, Product Price > 0.
Exercise 4: Build an aggregate to show all orders for a given customer.
Exercise 5: Sort orders by OrderDate descending.
Example 1: Employee Directory
Entities: Employee, Department
Aggregate: Show all employees in the selected department
Example 2: Sales Dashboard
Entities: Customer, Order, Product, OrderItem
Aggregate: Show top 5 customers by total purchase amount
Why is data modeling important in low-code apps?
What are the advantages of using aggregates vs. advanced SQL?
How do relationships affect data integrity?
What are common mistakes beginners make when designing entities?
Multiple Choice Questions:
Which of the following is a One-to-Many relationship?
a) Employee → EmployeeDetail
b) Department → Employees ✅
c) Students ↔ Courses
d) Product → Price
Which data type should be used for storing decimal values?
a) Text
b) Decimal ✅
c) Integer
d) Boolean
What is the primary purpose of an aggregate in OutSystems?
a) Build UI screens
b) Retrieve and filter data from entities ✅
c) Create workflows
d) Deploy apps
Which of these is a best practice for data modeling?
a) Avoid normalization
b) Use meaningful names ✅
c) Store sensitive data without encryption
d) Skip documenting relationships
Practical Task:
Create entities Customer, Order, Product.
Set up relationships.
Build an aggregate to display all orders for a specific customer.
Publish and test the app. Screenshot results.
OutSystems Documentation on Data Modeling: https://success.outsystems.com/Documentation
OutSystems Guided Paths: “Data Modeling and Database Design”
Video Tutorials: OutSystems Academy YouTube channel (Search: “Data Modeling in OutSystems”)
Sample Apps: Explore OutSystems Forge for database-driven apps
This module is fully ready for teaching, with concepts, practical steps, labs, examples, discussions, and assessments.
Module 3 of the OutSystems AI Low-Code Development Training, corresponding to Week 3: User Interface & Screen Design. This module is fully detailed with learning objectives, key concepts, step-by-step instructions, exercises, examples, discussion questions, and assessments.
By the end of this module, learners will be able to:
Explain the principles of user interface (UI) and user experience (UX) design in low-code applications.
Create screens using OutSystems visual editors.
Use widgets, templates, and layouts effectively.
Implement navigation patterns between screens.
Build responsive designs suitable for web and mobile applications.
Consistency: Uniform layout, color, and typography across screens.
Clarity: Make actions and information intuitive for users.
Feedback: Show visual feedback for user actions (loading, success, error).
Responsiveness: Screens should adapt to desktop, tablet, and mobile.
Accessibility: Consider color contrast, font size, and keyboard navigation.
Screen Type
Description
Example Use Case
Blank Screen
Start from scratch
Custom forms
List Screen
Displays multiple records
Employee directory
Detail Screen
Shows details of a selected record
Employee profile
Form Screen
Allows data input
Create/Update Employee
Dashboard
Visualize metrics
Sales performance
Use OutSystems UI templates for consistent design.
Layouts define the header, footer, and sidebar structure.
Themes control colors, fonts, and spacing.
Label: Static text
Input: User data entry
Button: Trigger actions or navigation
Table: Display lists of data
Container/Block: Group elements visually
Chart: Display analytics or metrics
Menu-based navigation: Top bar, sidebar
Breadcrumbs: Show hierarchical navigation
Links/Buttons: Navigate between screens
Mobile gestures: Swipe, tap, and pull-to-refresh
Use OutSystems Breakpoints to adapt layouts:
Desktop
Tablet
Mobile
Use flex containers to dynamically resize content.
Test across devices to ensure usability.
Open Service Studio → Interface tab → Screens.
Click Add Screen → From Template (e.g., List, Form, Dashboard).
Name the screen (e.g., EmployeeList).
Drag widgets onto the screen: Labels, Inputs, Buttons.
Add an Aggregate or Advanced Query to fetch data.
Bind the data to widgets (e.g., Table, List).
Configure columns, headers, and sorting options.
Use Link widgets to navigate to other screens.
Set Destination: e.g., Detail Screen of selected record.
Test navigation in 1-Click Publish mode.
Apply OutSystems theme for colors and fonts.
Use Containers and Blocks to group related widgets.
Set flex properties for responsive behavior.
Preview using Tablet and Mobile breakpoints.
Exercise 1: Create a List Screen showing all employees from Module 2.
Exercise 2: Create a Detail Screen for individual employee records.
Exercise 3: Add a Form Screen to create and update employee details.
Exercise 4: Implement navigation links between List, Detail, and Form screens.
Exercise 5: Test responsive design across desktop, tablet, and mobile views.
Example 1: Employee Directory App
List screen shows all employees
Detail screen shows employee profile
Form screen updates employee information
Example 2: Sales Dashboard
Dashboard screen displays charts for sales data
Table widget lists top-selling products
Navigation links to product detail pages
Why is responsive design important in modern apps?
How do widgets and templates accelerate app development?
What are the best practices for navigation in web and mobile apps?
How can we make screens more accessible for all users?
Multiple Choice Questions:
Which widget is used to display multiple records in a structured way?
a) Label
b) Table ✅
c) Input
d) Button
What is the primary purpose of a Form Screen?
a) Display dashboards
b) Collect and update data ✅
c) Navigate between screens
d) Manage themes
Which OutSystems feature allows screens to adapt to different devices?
a) Aggregates
b) Breakpoints ✅
c) Actions
d) Entities
Which of these is a navigation best practice?
a) Use breadcrumbs for hierarchical pages ✅
b) Hardcode links only
c) Avoid menus entirely
d) Only use back buttons
Practical Task:
Build a simple Employee Management interface with:
List Screen showing all employees
Detail Screen for selected employee
Form Screen to edit employee info
Responsive layout tested on desktop and mobile
OutSystems Documentation on UI & Screens: https://success.outsystems.com/Documentation
OutSystems Guided Paths: “UI Patterns and Screen Design”
Video Tutorials: OutSystems Academy YouTube channel (Search: “OutSystems Screen Design”)
Sample Apps: Explore OutSystems Forge for UI-focused applications
This module is fully ready for teaching, including concepts, practical steps, labs, examples, discussions, and assessments.
Module 4 of the OutSystems AI Low-Code Development Training, corresponding to Week 4: Business Logic & Actions. This module is fully detailed with learning objectives, key concepts, step-by-step instructions, exercises, examples, discussion questions, and assessments.
By the end of this module, learners will be able to:
Understand the role of business logic in low-code applications.
Create and manage server-side actions and client-side actions in OutSystems.
Implement validations, conditions, and error handling in logic flows.
Use local and session variables to store and manipulate data.
Debug and test business logic effectively.
Business logic defines how data is processed, validated, and manipulated in your application.
Can be implemented server-side (back-end) or client-side (front-end).
Visual workflows (Flow Diagrams) are used instead of traditional coding.
Executed on the server, usually for:
Database operations (CRUD)
Complex calculations
Integrations with APIs or external systems
Can return data to screens or other actions.
Executed in the browser or mobile app.
Usually for:
UI interactions (show/hide elements, field validation)
Local calculations
Temporary data storage in variables
Type
Scope
Use Case
Local
Screen-specific
Temporary values in UI
Input
Passed into action or screen
Receive data from another screen
Output
Returned from action
Send results back to screen
Session
User session-wide
Store logged-in user info
If / Else statements control logical flow.
Used to execute different actions based on conditions (e.g., Salary > 50000).
Use Exceptions and Error Screens to handle failures gracefully.
Example: If API call fails, show user-friendly message.
Logging errors for debugging and auditing.
Go to Logic → Actions → Add Server Action.
Name the action (e.g., CalculateBonus).
Drag Assign, If, and Query elements to define logic.
Define Inputs (e.g., Salary) and Outputs (e.g., BonusAmount).
Click 1-Click Publish and test in Service Studio.
Example:
Input: Salary = 60000
Logic: If Salary > 50000 → Bonus = 10% of Salary
Output: BonusAmount = 6000
Go to Interface → Client Actions → Add Client Action.
Name the action (e.g., ValidateEmail).
Use If / Assign / Notify widgets to implement UI logic.
Bind client actions to buttons or events.
Example:
Input: Email = "user@example.com"
Logic: Check if email contains @ → Show warning if invalid
Open Variables tab in screen.
Add a Local Variable: InputSalary.
Assign values from user input fields.
Pass variables to server or client actions as needed.
Set breakpoints on actions.
Use 1-Click Debug in Service Studio.
Inspect variable values and flow execution.
Correct errors and republish.
Exercise 1: Create a server-side action CalculateTax that returns 15% of salary if > 50,000.
Exercise 2: Create a client-side action ValidatePhoneNumber to ensure a 10-digit format.
Exercise 3: Implement an If / Else logic to show messages based on salary brackets.
Exercise 4: Use local and session variables to store user input and display personalized messages.
Exercise 5: Debug your CalculateTax action and inspect variable values during execution.
Example 1: Employee Bonus Calculator
Inputs: Salary, Years of Service
Server-side logic calculates bonus
Client-side action shows formatted message: “Your bonus is $X”
Example 2: Form Validation
Client-side action validates Email and Phone fields before submitting
Server-side action saves record to database if valid
What are the differences between server-side and client-side actions?
Why is error handling important in business logic?
How can variables improve code modularity and reusability?
When would you use an If / Else condition vs. separate actions?
Multiple Choice Questions:
Which type of action executes on the server?
a) Client Action
b) Server Action ✅
c) Local Variable
d) Screen Widget
What is the main use of a session variable?
a) Store temporary UI-only values
b) Store user-specific data for the session ✅
c) Return data from server actions
d) Bind data to tables
Which widget can show messages to the user during client-side validation?
a) Label
b) Notify ✅
c) Input
d) Container
What is the purpose of debugging actions in Service Studio?
a) Change the theme of the app
b) Inspect logic flow and variable values ✅
c) Publish the app
d) Create new entities
Practical Task:
Create a Salary & Bonus App:
Input employee salary
Client-side validation for positive numbers
Server-side action calculates bonus
Display result on screen
Debug the action and verify output
OutSystems Documentation: Server and Client Actions: https://success.outsystems.com/Documentation
Guided Path: “Business Logic and Actions”
Video Tutorials: OutSystems Academy YouTube channel (Search: “OutSystems Actions and Logic”)
Sample Apps: Explore OutSystems Forge for logic-focused apps
This module is fully ready for teaching, with concepts, step-by-step exercises, examples, discussions, and assessments
Here’s Module 5 of the OutSystems AI Low-Code Development Training, corresponding to Week 5: Integrations & REST APIs. This module is fully structured with learning objectives, key concepts, step-by-step instructions, exercises, examples, discussion questions, and assessments.
By the end of this module, learners will be able to:
Understand the purpose of integrating external systems with OutSystems apps.
Consume REST and SOAP APIs in OutSystems.
Handle authentication and headers when connecting to external services.
Map API responses to OutSystems entities or variables.
Implement API error handling and logging.
API (Application Programming Interface): A method for applications to communicate and exchange data.
REST API: Uses HTTP methods (GET, POST, PUT, DELETE) and JSON for data exchange.
SOAP API: Uses XML messages and predefined WSDL for structured communication.
Retrieve data from external systems (e.g., CRM, ERP, HR systems).
Push data to other platforms (e.g., notifications, analytics).
Automate workflows across multiple applications.
Type
Description
Example
Basic Auth
Username and password in header
API with simple login
API Key
Token passed in headers or query
Public APIs like weather APIs
OAuth 2.0
Secure token-based authentication
Salesforce, Microsoft Graph
Response Mapping: Convert API JSON/XML fields into OutSystems variables or entities.
Aggregates & Lists: Display API data in tables or charts.
Error Handling: Check response codes (200 OK, 401 Unauthorized, 500 Server Error).
Always validate inputs before sending to API.
Handle errors gracefully with user-friendly messages.
Use caching if data doesn’t change often.
Log API calls for debugging and auditing.
Modularize API calls using Reusable Server Actions.
Open Service Studio → Logic → Integrations → Consume REST API.
Enter the API endpoint URL (e.g., https://api.openweathermap.org/data/2.5/weather).
Click Fetch & Import → OutSystems automatically generates:
Methods (GET, POST, etc.)
Input and Output structures
Basic Auth: Set username and password in REST API method properties.
API Key: Add a header parameter (e.g., x-api-key) or query string.
OAuth 2.0: Configure token retrieval and refresh logic using OutSystems OAuth actions.
Map API JSON response fields to OutSystems Structures.
Bind the structure to widgets (Table, List, Charts).
Test response in 1-Click Publish → Preview.
Use Server Actions to call APIs and handle responses.
Assign outputs to local variables or entities.
Handle different response codes using If / Switch logic.
Check StatusCode returned by API.
Show Notify widget with user-friendly message if API fails.
Log errors in Service Center for monitoring.
Exercise 1: Connect to a public REST API (e.g., OpenWeatherMap) and display current weather on a screen.
Exercise 2: Map JSON response fields to a List widget in OutSystems.
Exercise 3: Add API Key authentication for secure access.
Exercise 4: Implement error handling for failed API calls (e.g., network error).
Exercise 5: Create a reusable Server Action to call API and return structured data for multiple screens.
Example 1: Weather App
Input: City name
REST API call returns temperature, humidity, and description
Display data in a table and dynamic labels
Example 2: Employee Info from HR System
REST API returns employee details
Map data to Employee entity
Show list of employees with filters
Why is REST API integration preferred over database direct connections for external systems?
What challenges can arise when consuming APIs in low-code apps?
How does error handling improve user experience and reliability?
Why should we modularize API calls into reusable actions?
Multiple Choice Questions:
Which HTTP method retrieves data from an API?
a) POST
b) GET ✅
c) PUT
d) DELETE
What is the purpose of mapping API responses to OutSystems Structures?
a) To format JSON for display ✅
b) To change API endpoint
c) To write custom SQL
d) To create UI widgets
Which authentication method uses tokens instead of username/password?
a) Basic Auth
b) API Key
c) OAuth 2.0 ✅
d) Session Variables
How should failed API calls be handled?
a) Ignore errors
b) Show user-friendly messages and log the error ✅
c) Stop the app
d) Only retry once without feedback
Practical Task:
Build a Weather Dashboard:
Input city name
Call OpenWeatherMap REST API
Display temperature, humidity, and description
Handle invalid city names gracefully
Log API call results in Service Center
OutSystems Documentation: REST API Integrations: https://success.outsystems.com/Documentation
Guided Path: “Integrating with REST APIs”
Video Tutorials: OutSystems Academy YouTube channel (Search: “REST API integration in OutSystems”)
Sample Apps: Explore OutSystems Forge for API-based applications
This module is ready for teaching, with concepts, practical steps, labs, examples, discussion points, and assessments.