OutSystems Platform Services

Table of contents

OutSystems platform services maximize the performance and security of applications, provide openness to continuous delivery processes, and support continuous innovation. All of these services run under the covers and underpin the top layer of the OutSystems architecture:

  1. Platform Server
  2. TrueChange
  3. Code Generator
  4. Deployment Services
  5. Application Services
  6. Mobile Application Build Service

Platform Server

This server component is the core of the OutSystems platform. It takes care of all the steps required to generate, build, package, and deploy applications. 

OutSystems doesn't use a proprietary runtime engine. All applications rely on standard architectures and frameworks. OutSystems Platform Server is what makes this possible. It takes care of all the steps required to generate, optimize, compile, and deploy applications into a standard web application server, or package into a native mobile app, and has a set of specialized services under the hood. Each of these services is described in the sections that follow.


TrueChange powers the OutSystems platform, removing the guesswork and repetition from development and delivery—at design time, build time, and runtime. This unique combination of automation, AI, and analytics checks for architecture errors and dependencies, provides team and architecture governance, and monitors performance in real-time. With TrueChange, developers do not have to install complex tools for configuration, worry about build and version control, or find the experts to set them up. 

At design time, when different developers are working on the same version of the module at the same time, and both publish the version, TrueChange  automatically determines the changes to be merged. It shows the developers, with visuals, the differences, and gives them the option to merge and publish.

At build time, TrueChange assures error-free and consistent application builds, deployments, and changes across all application components. TrueChange performs automated impact analysis and bug checking so that developers and architects avoid long, laborious dependency checking and debugging processes and get their mobile and web apps to market faster. Change processes are automated, including all database change scripts and the impact this change will have on an application.

At runtime, TrueChange provides automated, AI-fueled analysis of an application’s implementation and execution metrics, along with recommended solutions. TrueChange enables performance or quality problems to be detected early and resolved quickly, which keeps costs low, delivers a great user experience, and enables responsive and effective IT.

Code Generator

The code generator service takes the application model that was developed in Service Studio and generates all the native application components, ready to be deployed to an application server. This includes:

  • Running a deep graph analysis on the application model that checks for external dependencies and applies optimizations to the application.
  • Checking for optimizations that can be done when generating the code, such as flagging a query that might be part of an application but is not used.
  • Generating integration proxies to isolate an application from changes made to external services.
  • Generating native code for all the layers in the application stack: from the SQL needed to interact with the database and the backend business logic services to the JavaScript components on the front-end.
  • Bundling session management, authentication, and configurations to the application.
  • Adding logging and monitoring capabilities to the application, so that developers can check for errors, audits, and performance metrics at runtime.
  • Generating the build scripts to upgrade the database model and to deploy the application.

Deployment Services

OutSystems deployment services deploy the generated application components to an application server and ensure the application is consistently installed on each front-end server of an organization's server farm. There are two different deployment components. The deployment service deploys a .NET application on a specific front-end server. The process is as follows:

  • The OutSystems code generator compiles the application models and sends the code to the deployment service on each front-end server.
  • The deployment controller monitors the deployment to ensure the application was successfully installed.
  • If all deployments are successful, the deployment controller updates the runtime database to match the data models that were created. If not, the deployment is canceled, and the old application version continues running without changes.

Application Services

OutSystems Platform Server also has services for managing the applications at runtime. There are two different services for this:

  • Scheduler Service
  • Log Service

Scheduler Service

The Scheduler Service manages the execution of scheduled tasks. At runtime, the scheduling service retrieves the next pending job from the metadata database and executes it.

Batch tasks are designed for horizontal scalability so they are distributed across all the front-end servers.

Log Service

Applications are automatically instrumented to create error, audit, and performance logs. At runtime, these metrics are captured asynchronously, so that the performance of applications is not compromised while they create a constant stream of metrics. The log service manages the error, audit and performance events of the applications.

The log service runs at a lower priority so that it doesn't compete with the normal processing of applications. At runtime, when an application generates an error, audit, or performance event:

  • The event is written to a standard message queue on the front-end server.
  • The log service running on the front-end server asynchronously retrieves the events from the message queue and adds them to the logs database.
  • The events can then be leveraged by the monitoring consoles to display errors, audits, or performance data. They can also be sent to external systems by using available APIs.

Mobile Application Build Service (MABS)

The Mobile Apps Build Service (MABS) is the OutSystems platform service responsible for getting a mobile app into a native app package ready to be installed on devices. MABS abstracts the complexity of compiling, packaging, and signing a native app for iOS, Android, or both, so that development teams build mobile apps with 1-click―from the back-end to native front-end.

Each request to MABS is queued and processed in parallel in an isolated sandbox to ensure that information is always secure. All communication with MABS is done via the Platform Server and through HTTPS, and only the necessary information to execute the build operation is sent to MABS. This means that no backend logic information is sent. MABS stores all information with encryption and only for the minimum necessary time to complete the process.

The build process that MABS executes is:

  • Create a new project in an OutSystems template that provides the base native app structure and default native capabilities.
  • Process app resources (icons, splash screens, configurations).
  • Set the mobile platform: iOS or Android.
  • Add native plugins.
  • Process keys to sign the app.
  • Build package.

When the mobile package is created, OutSystems deletes all information, collects the application package, and returns it to the developer.