Dev@Scale in ODC: Turbocharging CI/CD with new DevOps APIs

Editor’s note: Duarte Castaño, Lead DevOps Engineer at OutSystems, is the co-author of this post.

Developing and delivering applications at enterprise scale demands more than just raw speed; it requires confidence, precision, and robust automation. For technical professionals and business leaders working in OutSystems Development Cloud (ODC), achieving true Dev@Scale means embedding modern continuous integration/continuous delivery (CI/CD) practices directly into the application lifecycle.

In ODC, applications run in containers from the development stage onward. This architectural necessity means every single code change must be designed to be production-ready from the moment it’s published. That’s why continuous delivery is absolutely essential.

The pillars of continuous delivery in ODC

Continuous delivery (CD) is the practice that ensures your teams can release quickly, predictably, and sustainably. With ODC, CD enables your team to:

• Keep code consistently production-ready.
• Safely deliver code, even when features are unfinished.
• Deploy to production with confidence.
• Deliver essential hotfixes straight from the Development environment.

This robust approach is supported by the unique structure of ODC assets and deployments.

ODC assets and deployment flow

ODC assets include Applications (Web and Mobile), Libraries, Workflows, and the Agent Workbench. The deployment process is designed for modern containerized architecture:

1. Packaging: When an Application is published, a version of its dependent Library is packaged together with the Application container.
2. Deployment: This complete Application container is then deployed into each subsequent stage where the respective configurations are applied.

Methodology and governance: Building product-oriented teams

You can have the best pipeline tools, but if your organizational structure is mismatched, you won’t truly benefit from Dev@Scale. To maximize velocity and guarantee delivery independence, your governance model should align with the concept of product-oriented teams. These long-lived teams are organized around a product mindset and support specific business domains. Each business domain should adhere to a loosely coupled architecture to ensure team independence throughout the lifecycle.

Anatomy of an agile product team

A typical ODC Product Team is cross-functional, with roles essential to managing the entire continuous delivery pipeline:

• Product owner: Defines the product vision, roadmap, and prioritizes features aligned with business goals.
• Architect: Designs the overall system architecture, ensuring scalability, performance, and integration.
• Tech lead: Guides technical direction, ensures best practices, and acts as a mentor and bridge.
• Developer: Writes, tests, and maintains code to build and deploy features.
• QA owner: Oversees quality assurance processes to ensure the product meets quality standards.
• DevOps: Manages infrastructure and deployment processes, facilitating smooth continuous integration and delivery.
• UX/UI: Focuses on user experience and interface design (often sourced by the center of excellence, or CoE).

The CoE plays a crucial supporting role, helping teams become fast and autonomous by providing expertise along with self-service solutions.

Implementing continuous delivery best practices

Modern CI/CD relies on incremental software development, which breaks up large changes into a series of smaller, incremental ones. Every new application version deployed must be atomic by keeping the codebase working throughout the process.

To maintain atomicity and delivery safety, we strongly recommend implementing the following Trunk-Based Development (TBD) patterns:

• Small batch: Focus on small changes for quicker feedback and lower risk.
• Feature toggles: This is a crucial technique for decoupling deployment from feature release, which boosts customer value and manages risk by hiding incomplete features in production.
• Automated testing: To gain confidence that existing functionality is not broken, you must have enough automated tests to receive ample feedback on whether the behavior has been changed (intended or not).

The game changer: Introducing ODC DevOps APIs

So, how exactly can you integrate these continuous delivery best practices and seamlessly automate the process in ODC? The answer is the newly available ODC DevOps APIs.

These are new APIs designed specifically to enable automations across key DevOps domains, making CI/CD in ODC robust and extensible.

Key components of DevOps API

This API is structured around six core services, designed to manage assets through their entire lifecycle—from creation and configuration to building and deployment.

1. Asset repository

The central hub for all managed artifacts.

• Capabilities: Discover & Filter Assets and Create & Manage Asset History.
• Asset types: Web Apps, Mobile Apps, Libraries, Workflows, and Agentic Apps.
• Example endpoint: GET ../asset-repository/v1/assets
  • Retrieves a list of all managed assets.

2. Build operations

Focuses on the compilation and packaging of assets.

• Capabilities: Retrieve Build Details & Logs and Start an asset build operation.
• Example endpoint: GET ../builds/v1/build-operations
  • Retrieves a list of builds associated with a specific asset revision.

3. Deployments

Manages the release and placement of assets into target environments.

• Capabilities: Manage Deployment Jobs, and Inspect Deployment Details.
• Example endpoint: POST ../deployments/v1/deployment-operations
  • Initiates a new request for a deployment job.

4. Portfolio

Provides a high-level view of the entire operational landscape.

• Capabilities: Retrieve Deployed Assets, and List Environments (stages).
• Example endpoint: GET ../portfolios/v1/environments
  • Retrieves a list of available environments (e.g., Development, Staging, Production).

5. Dependency management

Tools for analyzing relationships and impact across assets.

• Capabilities: Launch Impact Analysis, and Explore Asset Dependency.
• Example endpoint: POST ../dependency-management/v1/deployment-analyses
  • Launches an analysis to assess the impact of a deployment change on dependent assets.

6. Asset configurations

Handles the dynamic settings and parameters for all artifacts.

• Capabilities: Application & Library Configuration, and Configuration for individual agents.
• Example endpoint: PATCH ../asset-configurations/environments/{environmentKey}/applications/{applicationKey}/configurations
  • Updates the configuration of a specific application in a defined environment.

Orchestrating the CI/CD pipeline

The ODC DevOps APIs are the engine that enables your external CI/CD Release Orchestrator tool (whether you choose a third-party application like Azure DevOps or Jenkins, or build a custom OutSystems orchestrator) to manage and automate complex deployment flows. The flexibility to integrate ODC into your existing DevOps ecosystem is yours:

1. The external CI/CD tool (the Release Orchestrator) initiates the deployment.
2. The Orchestrator uses the ODC APIs to perform initial deployment activities:
   • Launch an impact analysis.
   • Create the deployment job.
   • Check the deployment status in a loop until completion.
3. Code quality check: Integrate checks for Mentor Code Quality findings.
4. Apply configurations.
5. Automated testing: Trigger and execute Automated Test Suites via a Component Test Manager.
6. Manual approval: Include manual gates for critical stages before moving to the next environment.

By using these exposed APIs, technical teams gain unprecedented control and flexibility to integrate ODC deeply into their existing DevOps infrastructure, allowing the tailoring of the pipeline to their precise organizational needs.

A quick note on deployments: While each DevOps API deployment targets one asset at a time, you can easily trigger parallel deployments to automate multi-asset releases using an orchestrator.

That sounds like the perfect closing for a successful presentation summary!

Watch the presentation

Implementing Dev@Scale in ODC is a journey that blends the right organizational structure (product-oriented Teams) with powerful technical enablement (ODC DevOps APIs). By adopting Trunk-Based Development patterns and using these new APIs to orchestrate your deployments, you gain the confidence and speed necessary for continuous delivery mastery.

To see Duarte Castaño, Lead DevOps Engineer, and Robert Carter, Team Lead of Expert Services walk through these concepts and demo the deployment automation live, watch the full presentation:

• Presentation: Dev@Scale in ODC: Implementing a Modern CI/CD
• Speakers: Duarte Castaño and Robert Carter

Key takeaways for implementing modern CI/CD in ODC

Implementing Dev@Scale is a holistic effort blending technology and culture. Remember these three key takeaways for achieving continuous delivery mastery in ODC:

1. ODC DevOps API is GA: These APIs are the foundation for deep automation and customization of your CI/CD pipeline.
2. Trunk-Based Development Patterns are key: Use patterns like Feature Toggles and Small Batch to ensure continuous delivery success and atomic changes.
3. Product-oriented teams: These teams are crucial for fostering delivery independence and ensuring fast development cycles.

Start using the ODC DevOps APIs today to build a modern, high-confidence CI/CD pipeline tailored for your organization’s scale!