Backend for Your Internal Developer Platform

Build CI/CD pipelines, automate infrastructure provisioning, scaling and destruction, orchestrate tests, and build any other workflow that is required for your IDP. 

❌ Without Cloudomation Engine

From a Lack of Standardization

Internal developer platforms (IDPs) consist of many different tools and services. Integrating them is challenging, often resulting in highly complex, hard to maintain, hand-scripted solutions. Outages are common, problem resolution is slow, extending the platform is difficult and costly.

✅ With Cloudomation Engine

To a Unified Platform that Reduces Operational Friction

Cloudomation Engine is a pure Python framework built for integrating, monitoring and orchestrating tools and services across different technologies and infrastructures. As a unified platform, it provides an overview of all platform components, speeding up problem resolution and simplifying cost management. Modifying existing services and adding new ones becomes simple and fast.

How It Works

Configuration

A native configuration management component in the Cloudomation Engine platform allows visual modeling and mapping of configurations (standards and custom). Configuration files in git repositories can be validated, created and updated automatically based on the configuration model in Engine. Configuration can be shown as structured data, or as form. Forms can be embedded in portal solutions like Backstage, or be used as standalone webapps. Platform engineers can choose which configuration options are available to developers to ensure correct usage, and reduce complexity for software engineers.

Integrate & Orchestrate

With broad integration features, Engine makes it simple to connect tools and services across technologies and infrastructures. Platform engineers can define workflows in Python to orchestrate tools and services, or to build services from scratch. Integration of services is possible via webhooks and custom APIs which can be defined in Engine, accept any payload, and return any custom response, or via connectors using standard APIs and protocols (REST, ssh etc.). Complex schedulers (written in Python and fully customisable) allow to define dependencies between services that ensure workflows are only started when all preconditions are met.

Pure Python

Write automations in standard Python. Use Engine features through its Python API. Readable and simple. Other structured data (locks, connectors, configurations for secret manager, RBAC etc.) are stored as yaml. All Engine content is stored and versioned in git, through which it can also be accessed and edited in your favorite IDE.

IDP Reference Architecture

Where does Cloudomation fit into your internal developer platform?

Outcome

Overview

One place for platform engineers to see and manage what happens in their entire infrastructure.

Maintainability

Modular automation with re-usable components, all in Python, make it easy and fast to extend services, or to build new ones.

Engineer Experience

Smoother and simpler experience for both platform and software engineers. 

Frequently Asked Questions

Why do I need a backend for my portal / IDP?

A portal is a graphical user interface for software engineers to access information and services. The portal itself however can’t automate anything. As a result, building an IDP largely consists of getting information and services into the portal so that engineers can use it from there. Integrating services with a portal is often a highly manual process featuring lots of custom scripts or handmade Backstage plugins (or similar things). The result is often a fragmented codebase that is fragile and hard to maintain. If you want a scalable platform that a small team of platform engineers can sustainably run for a large number of software engineers, an IDP backend (or platform orchestrator) will make your lives a lot easier by providing a layer of abstraction and functionality that allows platform engineers to tie together services, orchestrate them in one place, and expose them to your portal in a standardised and sustainable way. 

Is Engine a platform orchestrator?

Yes, Engine is a platform orchestrator.

Is it possible to build an IDP only with Cloudomation Engine?
It is, though we generally recommend using a dedicated portal solution (like Backstage) as a frontend for developers. It is possible to define forms in Engine that developers can use to configure and trigger a workflow defined in Engine, but those are single forms which do not form a unified interface, and are also not built to accommodate portal use cases like documentation. 
 
Engine can serve as the only backend for your portal. As a general-purpose Python framework, it can be used to build CI/CD pipelines, automate infrastructure provisioning, scaling and destruction, orchestrate tests, and build any other workflow that is required for your IDP. 
 
Alternatively, you can use Engine to orchestrate existing services and pipelines, connecting them to the Engine platform to have one place where you can monitor and manage everything. 
 
The most common case is a mix-and-match approach: Engine is used to integrate existing scripts, pipelines and services, to extend them where required, and to build new services from scratch in addition to existing ones. 
How is Engine different from Humanitec?
Major differences are that Engine is a full end-to-end Python-based automation framework that features object-oriented automation (read about object oriented automation), while Humanitec is a configuration-based automation tool that features graph-based resolution of configuration dependencies. Humanitec is not a full automation platform, while Engine is (read about the difference between configuration-based and code-based automation). As such, the feature set of Engine is a lot broader and allows it to cover more use cases than Humanitec.

Meet Your New Platfrom Engineering Tool

Streamline operations, optimize collaboration, and deliver faster. Let’s discuss how our platform can help you overcome challenges and hit your goals.