Skip to main content



OutSystems architecture

While the underlying OutSystems architecture is not apparent to the end-users of the apps, the developers creating them, or even the operations teams managing them, our architecture brings a significant number of benefits.

We are completely transparent with our architecture to highlight how it maximizes the performance and security of your applications, provides openness to your continuous delivery processes, supports our continuous innovation, and to demonstrate how a standard architecture is the only way to fully ensure you're never locked-in to a proprietary solution.

Platform Server

OutSystems Platform Server is the core of OutSystems. It is a server component that complements a standard web application server stack with a set of services.

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 and has a set of specialized services under the hood:

  • Code generator: This takes the application modeled in the visual editor and generates, compiles and assembles standard applications, secured and optimized for performance, running on top of standard technologies.

  • Deployment services: These deploy the generated applications to a standard web application server, ensuring that your application is consistently installed on each front-end of your server farm / cloud infrastructure.

  • Application services: These manage the execution of scheduled batch jobs, and provide asynchronous logging services to store events like errors, audits and performance metrics.

Code generator

This compiler takes the application model that was developed in the visual editor and generates all the native application components, ready to be deployed to an application server.

When the code generator retrieves the application model, it:

  • Runs a deep graph analysis on the application model. This graph is used to check for external dependencies and apply optimizations to the application.

  • Checks for optimizations that can be performed when generating the code. For example, if an application has a query to fetch data from the database, but the result of the query is never used in application, the optimizer flags the query to be removed.

  • Generates integration proxies to isolate an application from changes made to external services.

  • Generates native code for all the layers in the application stack: from the SQL to interact with the database, and the backend business logic services, to the JavaScript components in the frontend.

  • Bundles session management, authentication and configurations to the application.

  • Adds logging and monitoring capabilities to the application, so that developers can check for errors, audits and performance metrics at runtime.

  • Generates the build scripts to upgrade the database model and to deploy the application.

Deployment services

The 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 deployment controller coordinates the deployment across all front-end servers as follows:

  • The deployment controller uses the OutSystems code generator to compile the application models.

  • Once the application is compiled, it sends the code to the deployment service on each front-end server. The deployment controller then 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: This service manages the execution of scheduled tasks.

  • Log service: This service manages the error, audit and performance events of the applications.

Scheduler service

OutSystems Platform Server supports the execution of scheduled batch jobs in applications. 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 runs at 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.