Skip to content
Beta

STACKIT Landing Zone Configurator

In 3 trails

Last updated on

The STACKIT Landing Zone Configurator turns reusable infrastructure building blocks into a guided workflow for platform and application teams. Platform Engineers configure the shared foundation and publish project templates. Application Owners use those templates to provision their Application Landing Zones through a common catalog.

The result is a repeatable path from platform design to migration-ready application environments: shared standards, visible ownership, reviewed changes, and explicit deployment decisions.

STACKIT documentation app.landing-zone.runs.onstackit.cloud Open the Landing Zone Configurator Use the hosted Configurator to prepare your platform foundation and application landing zones. Open the documentation Open the Landing Zone Configurator demo

The Accelerator provides reusable infrastructure code; teams use it directly through CLI and pipelines or through the Configurator's editor, templates, and authorized Runner

The Landing Zone Accelerator supplies the OpenTofu/Terraform modules and reference configurations. It is the infrastructure foundation for governance, identity, networking, shared services, and application projects.

The Landing Zone Configurator adds the working experience around that foundation: a visual editor, an Assistant, versioned project templates, and controlled infrastructure execution. Both direct IaC use and the guided Configurator workflow build on the Accelerator. Teams choose the working approach that fits their operating model.

Explore the Landing Zone Accelerator

The Web UI uses the Configurator API for validation, Assistant proposals, templates, and job orchestration; an isolated OpenTofu Runner provisions customer landing zones

The browser brings editor, chat, catalog, and job views together. The Configurator API coordinates identity, validation, Assistant proposals, versioned templates, and deployment jobs. STACKIT Model Serving supplies the models used by the Assistant.

An isolated Runner performs the authorized infrastructure operation with the versioned Accelerator. Configuration and job records support continuity across the workflow, while technical credentials are handled through the separate credential-management path.

Platform Engineers configure the platform and publish approved template versions; Application Owners select those versions and provision separate application instances

Select the organization and working environment for the task. STACKIT sign-in establishes identity; workspace membership, catalog access, and technical execution permissions establish what each person can do. Assign membership administration and credential delegation to the appropriate responsible people.

Open the hosted Configurator and establish the context for the work before choosing a configuration or project offering.

Ready to continue: The team knows where it is working, who owns the result, and which delivery workflow to follow.

Open the Configurator

Start with a reference configuration that matches your target architecture: a small standalone foundation, shared hub-and-spoke connectivity, or a topology with separate organizational, environment, tenant, or regional domains.

Use the editor to review foundations, folders, networking, platform services, project templates, and operations settings. Work from the enterprise ownership model, address plan, security requirements, and migration discovery findings. Select the capabilities needed for the organization, then review the resulting configuration as a whole.

Output: A coherent platform draft connecting the reference topology to the organization’s requirements. Save the reviewed configuration as the basis for platform delivery and template preparation.

The Platform Owner defines shared services, a mandatory governed application path and a separately approved sandbox; Application Owners choose approved offers, not an audit opt-out

The Platform Owner decides the platform’s operating rules; Platform Engineers translate them into a reviewed Configurator configuration. This is an ownership responsibility, not an additional Configurator login role.

Use audit logging as the running example: a governed application environment must send its STACKIT control-plane audit events to the central platform. An experimental sandbox may sit outside that collection scope when the Platform Owner explicitly approves the exception.

Demo question: How does the platform make the governed path repeatable while keeping the sandbox exception deliberate?

Choose the platform topology in the Configurator

Section titled “Choose the platform topology in the Configurator”

The Configurator combines folders, network and platform services into distinct governed application and approved sandbox domains with visible ownership and audit scope boundaries

Select the reference configuration in the Configurator, then adapt it to the platform mandate rather than treating the example as the final design.

Output: A platform draft with visible application and sandbox boundaries. Next, configure the central services and the audit collection scope.

Define mandatory audit logging and sandbox scope

Section titled “Define mandatory audit logging and sandbox scope”

The Platform Owner publishes templates with fixed audit obligations or an approved sandbox exception; the Application Owner supplies exposed parameters and cannot disable mandatory audit logging

The Platform Owner translates the audit rule into the approved project template. For the governed offering, the Telemetry Link and its central destination are part of the fixed standard, not optional order parameters. The Application Owner consumes the published version and cannot disable mandatory audit logging.

An organization-wide Telemetry Link covers sandbox projects in that organization too. To demonstrate an exempt sandbox, use the selected folder/project scope: an included parent scope still includes its projects. A sandbox label is not an audit opt-out.

Decision: Keep the audit obligation in the platform-owned template and target placement. Do not expose it as a per-order “disable audit logging” choice. Record the approved exception, responsible team and review point alongside the configuration.

Telemetry Link in the Application Landing Zone sends audit events to the platform Telemetry Router, which routes in parallel to an S3 archive and directly to Loki inside Observability; Grafana queries Loki

This example illustrates the platform audit design with direct Loki ingestion.

  1. A Telemetry Link in the governed application project sends audit events.
  2. The Telemetry Router in the Platform Landing Zone receives the control-plane audit events.
  3. The router sends them to two destinations: S3-compatible Object Storage for the archive, and directly to Loki within the Observability module for querying.
  4. Grafana, also part of Observability, queries Loki to investigate the events.

Archive and query serve different purposes. The application team uses the shared audit path; the platform team owns routing, retention, reader access and the investigation view.

Describe the intended outcome in the context of the configuration: for example, a shared corporate network with application projects for development and production. The Assistant helps explain the available configuration and proposes changes for review.

  1. Describe the requirement and the choices already agreed with the platform team.
  2. Review the field-by-field differences and answer any clarification questions.
  3. Accept the desired changes into the configuration draft.
  4. Review the full configuration and save it explicitly.
  5. Continue with the deployment review when you are ready to provision.

Human decisions remain visible throughout: accepting a proposal updates the draft, saving records the configuration, and approving deployment starts the infrastructure change.

Use the Assistant to turn the Platform Owner’s rule into a reviewable configuration proposal. Begin with the agreed scope and the intended central services:

Prepare central audit logging for our governed application scope, with an S3 archive and direct ingestion into Loki within Observability. Keep the approved sandbox outside that collection scope. Ask me to confirm retention, reader access and Object Lock choices.

Review the proposal against this platform design and the chosen scope. Check the router’s two destinations, the Observability/Loki ingestion path and reader access. Keep mandatory audit behavior fixed in the governed project template; publish the approved sandbox as a separate offering. Accept, save, Plan and Apply remain separate actions.

Keep configuration revisions aligned with your team’s review process. Save work in the Configurator, optionally connect GitHub for fork-based versioning, or export native inputs for an independent OpenTofu/Terraform workflow.

Agree which workflow owns changes for each environment. Record the reviewed configuration and source version together with the delivery decision so platform and application teams can identify the baseline they are using.

Review checkpoint: Confirm the saved revision, intended target, and change owner before moving from configuration work to infrastructure execution.

Create a Plan from the saved platform configuration, intended deployment target, and authorized credential profile. Follow the execution output and use the proposed resource changes as the basis for the deployment decision.

Decision: Accept the reviewed saved Plan for explicit Apply, or return to the configuration with a clear change request.

Save configuration, create and review its Plan, confirm target, services, scope and ownership, then explicitly authorize Apply of the reviewed saved Plan and follow the Runner result

Save the reviewed configuration and prepare its Plan with the intended platform target and authorized credential profile. Use the resource preview to connect the platform decision to the proposed infrastructure.

Authorize Apply of the reviewed saved Plan explicitly and follow the Runner job to its result. Then validate the event path and the sandbox boundary before accepting the platform.

Output: A deployed audit baseline ready for the controlled demonstration.

A draft is reviewed and saved, then a Plan is created and reviewed before a separate Apply decision starts the Runner and produces an environment for validation

The Configurator coordinates the job; the isolated Runner executes the versioned Accelerator with OpenTofu. Authorize Apply of the reviewed saved Plan and follow the job to its result.

  • Validate the foundation: Check the delivered organization structure, shared connectivity, and selected platform services against the reviewed design.
  • Record the baseline: Retain the configuration revision, deployment reference, and platform target for later application delivery.
  • Accept ownership: Identify the responsible platform team and agree operational handover.

Output: An accepted shared foundation from which the team can publish application project offerings.

A controlled event is retrieved from S3 and found through Grafana querying Loki; separate checks demonstrate mandatory template behavior and the approved sandbox collection boundary

Make the platform rule observable before offering it to application teams.

Use a controlled non-production demonstration and confirm scope, archive retrieval and reader access with the platform team. The sandbox exception concerns this central audit route; it is not a promise that no other logging exists.

Output: A demonstrated platform policy, with named audit readers, an archive owner and an accepted sandbox boundary.

Grafana Audit Logs Dashboard with total events, regional activity, HTTP methods, API actions and a raw audit log list

The screenshot shows the investigation view of the central audit path. It combines event volume and regional activity with API actions and an individual event’s details.

  • Orient: Use the event count and activity timeline to identify the relevant period.
  • Narrow: Filter by service, region, instance, level or action.
  • Investigate: Open a matching event in the raw audit log list and inspect its metadata.

This is the visible outcome of shared collection, not another step in the routing chain. The template rule and sandbox exception remain separate platform decisions.

The accepted platform supplies a revisioned Platform Contract and a separate service and policy package to application delivery; credentials remain in authorized execution bindings

The deployed Platform Landing Zone is the shared foundation. Its Platform Contract provides the reviewed, non-secret references that an application delivery workflow uses instead of rediscovering that foundation.

Keep audit-service references and the governance decision as companion information to the contract’s target references. Technical credentials stay in their authorized binding path, separate from the handoff document.

Output: An accepted foundation, a revisioned Platform Contract and a small service/policy handoff package. Agree which delivery workflow owns each application’s resources.

Turn the platform design into a small set of project offerings that application teams can understand and reuse.

Output: A reviewed project template draft with a clear purpose, target, parameter contract, and owning platform team.

A project template draft becomes an immutable published version used by separate application instances; later template versions are offered as a new choice

Project templates translate platform standards into reusable application project offerings. Choose the project type, region, network relationship, and service settings. Decide which values are fixed by the platform and which parameters an Application Owner supplies.

Review the template, bind it to the intended platform target, and publish a version for the permitted catalog audience.

Outcome: A reusable catalog offering. Existing instances retain their selected version; subsequent publications become new choices for application delivery.

Validate the offering with an Application Owner before repeating it across teams and migration waves.

Output: A demonstrated self-service path and a short feedback list for the next template version. Agree the owner of each improvement before expanding the catalog.

Follow the Application Owner workflow

The Application Owner consumes the platform offering, rather than configuring the platform.

  • Choose: Select an approved project offer and provide its exposed parameters.
  • Review: Confirm the project target and Plan, then explicitly start the authorized Apply.
  • Accept: Validate the environment and its platform-defined audit path before workload delivery.

A sandbox is a separate approved choice, not an audit bypass switch on a governed project. The detailed application workflow remains in the dedicated self-service Trail.

An Application Owner selects a published template available in their working environment. They review its platform target and fixed settings, enter the exposed project parameters, and place an order. The order identifies the selected version and the intended application environment.

Decision: Select one offering and version for the intended application environment, then provide the project-specific values.

Use the parameters exposed by the selected template to describe this particular application environment. For example, a finance application may need a clearly named development project before its production environment is delivered.

Output: A complete set of project values reviewed against the selected template version. Use the same identity and environment description in the later workload runbook.

An order turns a reusable catalog offering into a concrete application instance with a traceable delivery record.

  1. Confirm the selected template version and platform target.
  2. Review the project parameters and intended ownership together.
  3. Place the order and follow its configured approval policy.
  4. Continue with the order’s Plan and resource preview.

Output: An identifiable application order binding the selected version, project values, and delivery status. Use that order when following jobs and coordinating the handover.

Review and create the application environment

Section titled “Review and create the application environment”

Follow the order’s Plan and use its resource preview to review the intended application environment before starting Apply.

Decision: Explicitly start Apply of the reviewed saved Plan through the authorized execution path, then follow the job to its result.

Turn the reviewed resource preview into an explicit deployment decision.

  1. Confirm that the saved Plan represents the intended application environment.
  2. Explicitly start Apply through the authorized execution path.
  3. Follow the execution job and record its result against the application order.

Next checkpoint: Validate the project and agreed access, then pass the environment references to the workload delivery team.

Accept the delivered environment against the order and the requirements for workload delivery. Application instances have their own lifecycle and state, separate from the shared platform.

Output: An accepted application environment and a handover record the workload team can use without rediscovering the platform decisions.

Platform delivery and template publication lead to an application project, a readiness review, workload migration, and operational acceptance

The Application Landing Zone is the target environment for the next delivery stage. Bring its project, network, identity, and service references into the workload runbook. Review workload-specific access, connectivity, observability, and recovery arrangements with the migration team before starting the wave.

For VMware Relocate, connect the prepared environment to the existing VM landing-zone and migration-tool runbooks. For other workload types, use the relevant target architecture and delivery workflow. Keep the environment acceptance and workload acceptance as identifiable milestones with named owners.

VM Application Landing Zone for Relocate

Use instance and job history to retain the relationship between configuration, selected template version, execution, and outcome. Review drift as a separate maintenance activity. Treat a version change as a reviewed delivery decision, and use an explicit deletion workflow when retiring an application environment.

Feed lessons from pilot workloads and migration waves into the next platform configuration and template versions. This closes the loop from platform standards to application delivery and back into continuous improvement.

Outcome: A repeatable lifecycle in which the current environment stays understandable and improvements become reusable for the next application team.

Cloud Framework Build a governed platform with the Configurator Follow the Platform Engineer workflow from requirements to platform deployment and published project templates. Open page Cloud Framework Provision an Application Landing Zone through self-service Follow the Application Owner workflow from template selection to an environment ready for workload delivery. Open page

Use the maintained source documentation for product details, access setup, and operational procedures.

Code & registry github.com Landing Zone Configurator documentation on GitHub Find the user guide, architecture, and maintained technical references alongside the Configurator source. Open the repository
Asset historyActive 2 of the last 12 weeksLWUpdatedNo updates · 1 bar = 1 week i
Maintainer
LWLukas WeberrußHead of STACKIT Cloud Migration Framework · STACKITOwnerActive 12 of the last 12 weeks · 58 updatesSTACKITwww.linkedin.com/in/lukas-weberruß-a360b081Contributed in STACKIT