App Lifecycle Manager (previously known as SaaS Runtime) lets you store, host, manage, and monitor software as a service (SaaS) applications on Google Cloud. App Lifecycle Manager manages Terraform deployments at scale, allowing you to manage both your SaaS application and the infrastructure that it runs on.
App Lifecycle Manager can be used in many ways by a variety of stakeholders within the SaaS pipeline. If your work aligns with any of the following roles, you can use App Lifecycle Manager to streamline your multi-tenant operations:
Platform administrator
Application developer
Architect
Compliance administrator
Platform engineer
Finance operations
App Lifecycle Manager provides the following benefits:
Simplify service management at scale: Automate lifecycle tasks such as tenant provisioning, staged rollouts, and feature flag management across your SaaS tenants.
Expand observability and control: Fine-tune updates and releases across configurable units to manage your SaaS offering with precision at scale.
Build consistency across Google Cloud: Manage services across Google Cloud, Google Distributed Cloud, Billing, Observability, and Resource Manager.
Promote modularity and reuse: Use a flexible, template-driven architecture that supports unit-based group updates, inter-unit dependencies, and repeatable deployments.
How App Lifecycle Manager works
App Lifecycle Manager deploys infrastructure and application artifacts that define your SaaS offering. Each component of your offering is defined by a Terraform configuration and modeled as a unit kind. You provision units (instances of a unit kind) for your tenants and update those units over time using versioned releases and configurable rollouts.
The App Lifecycle Manager architecture is built around the following core concepts:
SaaS offering (
Saas): The top-level resource that represents your SaaS product and defines the available regions where your resources and units reside.Composite templates and blueprints: The Terraform configurations that specify the Google Cloud resources for your offering. You can design and connect composite templates from Application Design Center, or package Terraform configurations directly into Open Container Initiative (OCI) blueprints stored in Artifact Registry.
Unit kinds (
UnitKind): Templates that define distinct, independently managed components of your SaaS offering (for example, a database tier or an application cluster). Unit kinds can declare dependencies and variable mappings so outputs from one unit automatically pass as inputs to dependent units.Units (
Unit) and tenants (Tenant): A unit is a deployed instance of a unit kind. Units are typically grouped by tenant and provisioned into dedicated tenant projects using Infrastructure Manager and a user-managed actuation service account.Releases (
Release): Immutable snapshots of a unit kind that reference a specific blueprint version and default input variables.Rollout kinds (
RolloutKind) and rollouts (Rollout): A rollout applies a new release across a fleet of units. Each rollout follows the rollout strategy, error budget, and unit filters defined in its rollout kind.Feature flags: Runtime configuration controls that let you toggle feature availability and behavior across units and tenants without redeploying infrastructure. For more information, see the Feature flags overview.
For full definitions of App Lifecycle Manager terminology, see the App Lifecycle Manager glossary.
SaaS tenancy models
App Lifecycle Manager supports silo, pool, and hybrid SaaS tenancy models so you can balance resource isolation, operational overhead, and infrastructure cost. By combining tenants and tenant projects, unit kind modeling, and variable mappings, you can control whether App Lifecycle Manager provisions dedicated resources for each customer or reuses shared infrastructure across customers.
Silo (single-tenant) model
In a silo model, each tenant receives dedicated application and datastore units
provisioned inside an isolated Google Cloud tenant project using the
tenant_project_id and tenant_project_number variables. A dedicated actuation
service account (actuation_sa), Identity and Access Management (IAM) policies, and a
Virtual Private Cloud (VPC) network help isolate each tenant's workloads and
data. In UnitKind dependency mappings, keep ignore_for_lookup: false (the
default) on a per-tenant lookup key such as tenant_project_id in a
ToMapping configuration. This configuration ensures that
App Lifecycle Manager provisions a dedicated dependency unit for each tenant
instead of reusing an existing unit from another tenant.
This model works best for regulated workloads, strict compliance or data-residency requirements, per-tenant release cadences, and straightforward per-project cost tracking. The following architecture shows how App Lifecycle Manager provisions dedicated units into separate tenant projects:
Pool (multi-tenant) model
In a pool model, tenants share application, cluster, or datastore units in a
shared infrastructure project, with logical separation at the application or
storage layer. Leaving the ignore_for_lookup field set to false (the
default) in a ToMapping configuration lets dependent units look up and reuse
existing shared dependency units when lookup keys match. You represent
customers as logical Tenant resources and categorize units with labels for
filtered rollouts. With
multi-tenant feature flags,
you can evaluate runtime attributes (such as customerID) so you don't need to
redeploy infrastructure to customize tenant behavior.
This model works best for high-density, cost-optimized offerings, self-service tiers, and uniform fleet updates where tenants share the same release schedule. The following architecture shows how multiple logical tenants share pooled units and runtime feature flag targeting:
Hybrid (bridge) model
In a hybrid model, a single SaaS offering combines shared pooled unit kinds
(reused across tenants through shared ToMapping lookup keys or shared units)
with isolated per-tenant unit kinds (provisioned per tenant project using keys
such as tenant_project_id with ignore_for_lookup: false). You run common
control, ingress, or compute services in a shared pooled tier. Then you use
variable mappings
to connect them to dedicated workload or database units in each tenant project
(tenant_project_id).
This model works best for tiered SaaS products that pair shared standard tiers with isolated enterprise tiers. This model also fits architectures that share an ingress plane while keeping sensitive customer data in separate projects. The following architecture shows how a single SaaS offering connects a shared pooled tier to isolated per-tenant units:
Tenancy model comparison
The following table compares the three SaaS tenancy models across isolation boundaries, implementation in App Lifecycle Manager, and common use cases:
| Tenancy model | Isolation boundary | Implementation in App Lifecycle Manager | Best for |
|---|---|---|---|
| Silo (single-tenant) | Dedicated tenant project, VPC network, IAM policies, and actuation_sa per tenant |
Separate tenant projects (tenant_project_id), dedicated units, and ToMapping with per-tenant lookup keys (ignore_for_lookup: false) |
Regulated workloads, strict compliance or data residency, custom release schedules, and per-project billing |
| Pool (multi-tenant) | Logical separation within shared infrastructure and application units | Shared unit kinds, ToMapping matching shared scope keys (ignore_for_lookup: false), unit labels, and runtime feature flags |
Cost-optimized high-density tiers, self-service onboarding, and uniform fleet updates |
| Hybrid (bridge) | Shared ingress or compute tier combined with isolated per-tenant workload or data projects | Mix of shared pooled unit kinds and per-tenant siloed unit kinds (tenant_project_id with ignore_for_lookup: false) linked by variable mappings |
Tiered enterprise offerings and shared control planes with isolated customer datastores |
Prepare your workload for App Lifecycle Manager
Before you deploy your SaaS offering, determine how to partition your application and infrastructure within the App Lifecycle Manager ecosystem.
Organize components of your SaaS offering that should be updated or scaled together into distinct Terraform configurations, and model each grouping as a separate unit kind. For example, you might model a shared network or database in one unit kind and your stateless application tier in a dependent unit kind.
Use composite templates with App Lifecycle Manager
To define the architecture of your App Lifecycle Manager offerings, use composite templates through Application Design Center.
When you attach a composite template to your SaaS offering, App Lifecycle Manager automatically populates the unit kinds, blueprints, and releases defined in your template. When you update the composite template in App Design Center, you can import the new template revision into your SaaS offering to deploy updates across your units.
For more information about authoring composite templates, see Design composite templates. For instructions on connecting a composite template to an offering, see Model and package units of deployment.
End-to-end workflow
Deploying and operating a multi-tenant application with App Lifecycle Manager follows four main stages:
Design and package your application: Author modular Terraform components and assemble a composite application template in Application Design Center, or package your Terraform configurations into OCI blueprints.
Configure projects and service accounts: Set up your producer and tenant projects and grant the required IAM roles to your App Lifecycle Manager service accounts.
Create and model your SaaS offering: Create a SaaS offering with your target regions, connect your composite template or define unit kinds in Model and package units of deployment, and configure variables and dependencies.
Provision units and deploy releases: Deploy unit instances for each tenant, and deploy subsequent updates across locations using rollout strategies as described in Update a SaaS offering.
To walk through this workflow step by step:
Follow the end-to-end tutorial, Design and deploy SaaS offerings, to build a multi-component composite template in App Design Center and deploy it across tenants with App Lifecycle Manager.
Try the quickstart to deploy a Cloud Run and Cloud Storage composite application template with App Lifecycle Manager.
Key operational concepts
As you plan your production architecture in App Lifecycle Manager, review the following standalone guides:
Service accounts: Learn about the Google-managed App Lifecycle Manager service agent, user-managed actuation service accounts (
actuation_sa), and optional artifact creation service accounts, along with the required IAM roles for each.Rollout strategies: Compare single-location, all-at-once, and progressive rollout strategies, and learn how rollout kinds use error budgets and unit filters to safeguard production updates.
Regionalization: Understand how available regions on a SaaS offering govern unit placement, rollout locations, automated resource replication, and location requirements for Artifact Registry and Developer Connect.
What's next
Try the quickstart to deploy a Cloud Run and Cloud Storage composite application template using App Lifecycle Manager.
Follow the end-to-end tutorial to design and deploy SaaS offerings.
Get started by creating a SaaS offering.
Review App Lifecycle Manager service accounts, rollout strategies, and App Lifecycle Manager regionalization.