Platform Strategy & Architecture
Define platform products, target architectures, Blueprints and technical guardrails.
Orthevs Engineering Lab · PEL
Design, deliver and operate platforms as products across their lifecycle.
The Platform Engineering Lab connects Blueprints, golden paths, clusters, add-ons, self-service, reliability and recovery in a Control Plane for standardized, governed platform offerings.
Documented target state · Concept / Architecture Baseline
Platform Product Lifecycle
InputOfferingBlueprintPolicies
Orthevs LabPELControl Plane
OutcomePlatformWorkspaceSLO Evidence
Health, drift, adoption, cost and recovery feed back into the offering
Domain application · target architecture
Independent engineering environment
The Lab is designed as a complete domain application with a workspace, editors, models and SDK-like interfaces. Its Factories are the specialist tools; Engines handle processing and execution. Shared Contracts connect it with other Labs.
Engineer platforms and clusters through design, deployment, operations and evolution.
From Engineering Contract to verifiable outcome
- 01
Contract & Foundation
Requirements and rules select the domain foundation.
- 02
Lab Workspace
Models, editors and tools address the domain problem.
- 03
Factory & Engine
Specialist tools create artifacts and use suitable execution mechanisms.
- 04
Validation & Product
Tests, evidence and approvals lead to a versioned outcome.
The workflows and capabilities shown describe the documented target model. Check availability and maturity for each release and capability.
Mission and ambition
Self-service is only a product when operations and recovery come with it.
PEL treats platforms and clusters as versioned offerings rather than one-off installation projects. An offering combines Blueprint, supported providers, security and operational policies, SLOs, quotas, support model and documented lifecycle operations.
Users choose a golden path and describe the desired state. PEL validates capabilities, creates a plan with cost and policy checks, requests approvals and orchestrates isolated runners. The observed state is regularly checked against the approved revision.
Kubernetes is the first prioritized target system, but not the boundary of the product domain. PEL replaces neither Kubernetes nor Terraform, Ansible, Cluster API, Helm or GitOps. It integrates these tools behind stable domain and operation contracts.
Capability map
Twelve domains structure the Platform Engineering Lab.
The domains organize responsibility and lifecycles. Within them, Factories deliver clearly bounded, versionable capabilities.
Infrastructure & Resource Provisioning
Provision providers, compute, network, storage and resource reservations under control.
Operating Systems & Node Engineering
Connect node roles, OS contracts, bootstrap, enrollment and node lifecycle with OSEL.
Cluster Engineering
Master cluster design, provisioning, fleets, upgrades and multi-cluster lifecycle.
Cluster Foundation Services
Manage network, storage, runtime and add-ons as a compatible cluster foundation.
Delivery, Configuration & Automation
Combine GitOps, configuration, releases and workflows into repeatable delivery pathways.
Developer Experience & Self-Service
Design portals, golden paths, environments and workspaces for safe self-service.
Platform Products & Shared Services
Deliver databases, messaging, registries, secrets and other services as standardized offerings.
Reliability, Observability & Operations
Bring together SLOs, telemetry, health, capacity, diagnostics and operations across platforms.
Security, Compliance & Governance
Embed policy, supply chain, security controls and Evidence in design, plan and operations.
Resilience, Backup & Recovery
Treat backups, restore, disaster recovery and continuity as regularly tested product features.
Lifecycle, Governance & Economics
Steer portfolio, cost, quotas, change, drift and decommissioning across the entire lifecycle.
Use cases
PEL starts with the complete engineering problem.
The scenarios combine several Factories into one dependable flow. They describe the documented target state, not a product function that is already committed.
1Greenfield
Deliver a Kubernetes offering as a golden path
A user selects an offering, parameterizes the Blueprint and receives plan, cost and policy results before execution. PEL provisions infrastructure, OS/nodes, cluster, network, storage, add-ons, security baseline, monitoring and backup, and concludes with acceptance and restore tests.
- One request instead of a toolchain
- Policies in every phase
- Ready only after operational checks
2Brownfield
Adopt existing clusters step by step
Read-only discovery and inventory form the starting point. PEL compares reality with the approved Blueprint, clarifies ownership and moves deliberately from Observed Only through Partially Managed to Fully Managed.
- No forced immediate takeover
- Ownership per resource area
- Risk and drift report before mutation
3Production Change
Cluster upgrades with stop and recovery gates
Support matrix, preflight, impact, maintenance window, backup and restore readiness are checked in advance. Control plane and workers follow safe batches; API, nodes, add-ons, services and SLOs are verified after each step.
- Plan and approval
- Batched execution
- Forward recovery with Evidence
4Platform Service
Offer shared services as operable products
Database, messaging, registry or workspace offerings are published with service classes, quotas, secrets, SLOs, backup, support and decommissioning, and made consumable via self-service.
- Service contract instead of one-off installation
- SLO and support tier
- Backup, restore and retirement
End-to-end lifecycle
From the requirement to the controlled next state.
PEL connects product definition and concrete platform instance through a failure-aware lifecycle with desired and observed state.
- 1Design
Define the offering
Set target audience, support, Blueprint, SLOs, policies, quotas and lifecycle.
- 2Validate
Check inputs
Validate schema, capabilities, providers, versions and dependencies.
- 3Plan
Make change visible
Produce diff, cost, risk, capacity and policy results in advance.
- 4Approve
Confirm accountability
Approve high-risk operations with maintenance window, backup and recovery path.
- 5Provision
Create base resources
Orchestrate infrastructure, OS/nodes and clusters through capability contracts.
- 6Configure
Complete the platform
Configure network, storage, runtime, add-ons, delivery and shared services.
- 7Verify
Prove product readiness
Check health, security, SLOs, backup and recovery before Ready.
- 8Operate
Deliver the service
Continuously steer workspaces, telemetry, capacity, support and cost.
- 9Update
Change under control
Update releases, clusters, nodes and add-ons with batches and health gates.
- 10Recover
Prove recoverability
Restore backups in isolation and demonstrate RPO, RTO and integrity.
- 11Retire
Dismantle in order
Handle dependencies, data, traffic, credentials and resources in a controlled way.
Closed feedback loop
Health, drift, adoption, cost and recovery feed back into the offering. Insights are not merely documented; they flow, versioned, into the next engineering cycle.
Reference architecture
Control Plane, Execution Plane and target platform have separate trust boundaries.
PEL plans and coordinates; isolated runners execute with minimal permissions; providers and clusters remain observable target systems.
Orthevs Platform
IAM, tenant, secrets, policy, event bus, audit, registry and artifact storage.
PEL Core & API
Catalog, desired/observed state, planning, approvals, workflow engine and operation ledger.
PEL Factories
Provisioning, clusters, add-ons, delivery, self-service, reliability and lifecycle.
Runners, providers and clusters
IaC/config runners, cloud, virtualization, bare metal, Kubernetes and shared services.
Declarative First
A typed desired state leads; observed state and generation remain visible.
Plan before Apply
Diff, cost, policy, risk and approval are part of the operation.
Reconcile within limits
Not every drift is overwritten automatically; ownership and risk decide.
Failure-aware
Resume, compensation and forward recovery replace fictitious atomic transactions.
Lab Core
Shared responsibilities keep the Factories integrable.
The Lab Core bundles the cross-cutting domain services; a Factory adds a capability without rebuilding these foundations in parallel.
Resource & Topology Registry for relationships, scope, ownership, versions and labels.
Shared PEL function for consistent APIs, lifecycles and verifiable handovers.
Desired-State Store and Reconciliation Controller for planned and observed state.
Shared PEL function for consistent APIs, lifecycles and verifiable handovers.
Plan Engine for dependencies, diff, impact, cost and security checks.
Shared PEL function for consistent APIs, lifecycles and verifiable handovers.
Lifecycle Orchestrator for platforms, clusters and nodes.
Shared PEL function for consistent APIs, lifecycles and verifiable handovers.
Factory Manager for plugin discovery, permissions, configuration and version compatibility.
Shared PEL function for consistent APIs, lifecycles and verifiable handovers.
Operation Center for job state, logs, retries, resume, cancel and traceability.
Shared PEL function for consistent APIs, lifecycles and verifiable handovers.
Provider/Adapter Registry for target-system and tool plugins.
Shared PEL function for consistent APIs, lifecycles and verifiable handovers.
Approval & Policy Bridge for central policies and domain approvals.
Shared PEL function for consistent APIs, lifecycles and verifiable handovers.
Credential Broker for access to secret management without persistence in jobs or logs.
Shared PEL function for consistent APIs, lifecycles and verifiable handovers.
Artifact/Provenance Index for IaC plans, manifests, images, SBOM and evidence.
Shared PEL function for consistent APIs, lifecycles and verifiable handovers.
Domain model and evidence
Offering, Blueprint and instance turn platforms into traceable products.
PlatformOffering and PlatformBlueprint describe the product; PlatformInstance, Cluster, NodePool and Workspace form concrete instantiations. ProviderConnection, FactoryInstallation, Operation, ArtifactRef and Observation keep execution and state together.
Domain metadata is stored transactionally, large artifacts in object storage or registries, and telemetry in observability systems. Credentials are only ever referenced and provided through controlled secrets backends.
PlatformOffering
Version, providers, Blueprints, policies, support tier and SLOs.
PlatformBlueprint
Composition, variable schema, dependency graph and revision.
PlatformInstance
Owner, environments, desired revision and lifecycle state.
Cluster & NodePool
Distribution, version, roles, size, placement and health.
Operation
Target, change set, idempotency, approval, status and Evidence.
Observation
Generation, health, conditions, freshness and time of observation.
Security, governance and operations
Self-service needs strong protective boundaries for every mutation.
PEL combines least privilege, policy-as-code, short-lived credentials and risk-based changes with verifiable recovery.
Check changes in advance
Every mutation shows scope, diff, cost, risk and expected impact.
- Schema and capability check
- Policy-as-code
- Explicit approval
Keep credentials in scope
Runners receive only time-bound, purpose-limited permissions for the operation.
- Short-lived tokens
- No unprotected kubeconfigs
- NetworkPolicies and isolation
Control the blast radius
Risk classes determine preflight, backup, maintenance window and four-eyes principle.
- Serialization per target
- Stop and resume criteria
- No blind destructive retry
Prove restore, not just backup
Only recovery tested in isolation counts as robust product evidence.
- RPO/RTO Evidence
- Integrity verification
- Regular DR exercises
Interplay within the Orthevs system
PEL composes platform products from specialized Lab capabilities.
PEL remains owner of the platform lifecycle and uses OS, infrastructure, security and workload capabilities through versioned contracts.
Offering→PEL Plan→IEL Resources→OSEL Nodes→SEL Gate→Ready Platform
Infrastructure Engineering
Provides sites, compute, network, storage and provider resources.
Operating System Engineering
Delivers signed OS releases, bootstrap and host readiness for nodes.
Security Engineering
Validates security profiles, findings, policies and release Evidence.
AI & ML Engineering
Consumes GPU capacity, workspaces and serving infrastructure as platform offerings.
Blockchain Engineering
Consumes node, validator, network and storage profiles for ledger systems.
Roadmap target state
A Kubernetes offering proves the complete platform lifecycle first.
Multi-cluster and marketplace follow only once provisioning, operations, upgrade, recovery and decommissioning are robust on one target provider. The phases are deliberately described without binding delivery dates.
- Phase 0Foundation
Scope, contracts and plan engine
Domain model, Factory contract, core APIs, IAM/tenant, provider matrix, ADRs and UI prototype.
Exit Gate: a Blueprint can be validated, versioned and planned. - Phase 1Operational MVP
Kubernetes on one target provider
Provisioning, nodes, cluster, add-ons, observability, backup, upgrade, repair and retirement.
Exit Gate: complete cluster lifecycle including a restore test. - Phase 2Enterprise
Multi-cluster and fleet operations
Separate scopes, multiple clusters, policy-driven fleets and a scalable Execution Plane.
Exit Gate: safe fleet operations across multiple platform instances. - Phase 3Marketplace
Platform service portfolio
Standardized service offerings with SLOs, quotas, support, economics and recovery profiles.
Exit Gate: services are discoverable, orderable and operable. - Phase 4Advanced Operations
Governance and recoverability
Validated recovery, air gap, cross-service operations and advanced governance.
Exit Gate: operational and recovery evidence supports the enterprise profile.
MVP scenario
Offering → Plan → Cluster → Operations → Upgrade → Restore → Retirement
The first vertical slice delivers a dev/test Kubernetes offering on a provider selected by ADR. A user can request, plan, approve, provision and operate it; upgrade, restore test and orderly decommissioning are explicitly part of the MVP path.
Deliberate boundaries
What the target state explicitly does not promise.
Named non-goals protect the Lab from a broad but unintegrated tool catalog and keep technical statements verifiable.
- PEL does not develop its own Kubernetes distribution or hypervisor implementation.
- IaC, configuration, GitOps and monitoring tools are integrated, not rewritten wholesale.
- Self-service does not permit autonomous production mutations outside of policies and change boundaries.
- Rollback is not promised as a complete reversal of irreversible infrastructure changes.
- Brownfield resources move into a managed state only after ownership has been clarified.
- The 48 Factories are a target catalog and are introduced through prioritized platform products.
PEL Factory Portfolio
48 capabilities across 12 domains.
Every Factory has its own detail page covering responsibility, use cases, artifacts and contract. The catalog represents the planned capability map.
Cluster Engineering
4 FactoriesCluster Design Factory
Design cluster profiles with topology, sizing, availability targets, security zones, and operating parameters.
Open detail page ↗Cluster Fleet Factory
Group multiple clusters into controllable fleets with consistent profiles, segments, and lifecycle rules.
Open detail page ↗Cluster Provisioning Factory
Provision clusters from approved designs through declarative provider and lifecycle contracts.
Open detail page ↗Cluster Upgrade Factory
Plan and control cluster upgrades with compatibility checks, staged execution, and fallback options.
Open detail page ↗Cluster Foundation Services
4 FactoriesCluster Add-on Factory
Manage approved cluster extensions together with configuration, dependencies, compatibility, and upgrade paths.
Open detail page ↗Cluster Networking Factory
Define cluster networks, CNI profiles, service communication, ingress, and related policies.
Open detail page ↗Cluster Storage Factory
Provide storage classes, volumes, snapshots, and data-retention profiles for cluster workloads.
Open detail page ↗Container Runtime Factory
Standardize container runtimes, registry access, runtime classes, and security parameters on cluster nodes.
Open detail page ↗Delivery, Configuration & Automation
4 FactoriesConfiguration Factory
Distribute versioned system and platform configurations to defined target groups under control.
Open detail page ↗GitOps Factory
Connect declarative platform state to Git repositories and automated, verifiable synchronization.
Open detail page ↗Release Factory
Control versioned platform releases through validation, promotion, rollout, and withdrawal.
Open detail page ↗Workflow Automation Factory
Compose Factory operations into repeatable workflows with conditions, approvals, and failure handling.
Open detail page ↗Developer Experience & Self-Service
4 FactoriesDeveloper Portal Factory
Present platform offerings, documentation, and self-service actions in a role-aware developer portal.
Open detail page ↗Environment Factory
Create standardized development, test, and production environments from versioned platform components.
Open detail page ↗Golden Path Factory
Compose approved tools, templates, and controls into reusable Golden Paths for teams.
Open detail page ↗Workspace Factory
Provide preconfigured workspaces with tools, access, and context for platform tasks.
Open detail page ↗Infrastructure & Resource Provisioning
4 FactoriesCompute Factory
Describe and provision compute resources with size profiles, placement, quotas, and lifecycle data.
Open detail page ↗Infrastructure Inventory Factory
Maintain a current inventory of infrastructure resources, relationships, ownership, and observed state.
Open detail page ↗Infrastructure Provisioning Factory
Plan and provision infrastructure resources through declarative blueprints and replaceable provider adapters.
Open detail page ↗Network Infrastructure Factory
Define and provision networks, segments, routing, name resolution, and controlled connectivity.
Open detail page ↗Lifecycle, Governance & Economics
4 FactoriesCost & FinOps Factory
Allocate platform costs to resources, teams, and products and expose optimization opportunities.
Open detail page ↗Decommissioning Factory
Control safe platform-resource decommissioning, including data handling, dependencies, and evidence.
Open detail page ↗Drift & Reconciliation Factory
Compare desired and observed platform state and control the remediation of deviations.
Open detail page ↗Platform Lifecycle Factory
Orchestrate platforms through provisioning, operation, change, modernization, and orderly retirement.
Open detail page ↗Operating Systems & Node Engineering
4 FactoriesNode Configuration Factory
Maintain node configurations as versioned desired state and apply changes in a controlled, verifiable manner.
Open detail page ↗Node Lifecycle Factory
Control the lifecycle of platform nodes from enrollment and maintenance through replacement and decommissioning.
Open detail page ↗Node Provisioning Factory
Prepare physical or virtual nodes for their platform role and hand them over in a validated state.
Open detail page ↗OS Image Factory
Build and maintain approved operating-system images for platform nodes with provenance and security evidence.
Open detail page ↗Platform Products & Shared Services
4 FactoriesDatabase Service Factory
Offer databases as a standardized platform product with service classes, lifecycle, and operational evidence.
Open detail page ↗Messaging Service Factory
Offer messaging infrastructure as a managed platform product with topologies, quotas, and operating profiles.
Open detail page ↗Platform Service Factory
Compose technical components into standardized, operable platform services with clear service contracts.
Open detail page ↗Secrets & PKI Integration Factory
Integrate secret management and PKI without persisting sensitive values in platform jobs or configurations.
Open detail page ↗Platform Strategy & Architecture
4 FactoriesCapacity Planning Factory
Forecast resource demand and capacity limits for platforms, clusters, and shared services.
Open detail page ↗Platform Blueprint Factory
Describe platform products as versioned target architectures with components, dependencies, policies, and an operating model.
Open detail page ↗Platform Catalog Factory
Curate approved platform offerings with versions, service classes, owners, and support status.
Open detail page ↗Topology Factory
Model resources, services, and their dependencies as a traceable platform topology.
Open detail page ↗Reliability, Observability & Operations
4 FactoriesIncident Response Factory
Structure technical response to platform incidents with roles, playbooks, evidence, and recovery steps.
Open detail page ↗Observability Factory
Standardize telemetry, dashboards, and alerting for platforms, clusters, and shared services.
Open detail page ↗Operational Maintenance Factory
Bundle recurring maintenance into controlled, schedulable, and auditable operational flows.
Open detail page ↗SLO & Reliability Factory
Define Service Level Objectives and connect reliability signals to platform operating decisions.
Open detail page ↗Resilience, Backup & Recovery
4 FactoriesBackup Factory
Define backup policies, schedules, retention, and verifiable backup runs for platform resources.
Open detail page ↗Business Continuity Factory
Model the technical continuity of critical platform services during prolonged disruptions.
Open detail page ↗High Availability Factory
Design and validate high-availability patterns for platform components across defined failure domains.
Open detail page ↗Restore & Disaster Recovery Factory
Orchestrate restore and disaster recovery with measurable recovery targets and regularly tested procedures.
Open detail page ↗Security, Compliance & Governance
4 FactoriesIdentity & Access Integration Factory
Integrate identity providers, roles, and access decisions into platform offerings and operational flows.
Open detail page ↗Platform Security Factory
Embed technical security baselines and safeguards in platform design, provisioning, and operation.
Open detail page ↗Policy & Compliance Factory
Translate policies and compliance requirements into verifiable platform controls, exceptions, and evidence.
Open detail page ↗Supply Chain Security Factory
Protect the provenance and integrity of platform artifacts through SBOMs, signatures, attestations, and release gates.
Open detail page ↗Shape PEL together
Which platform offering should work as a golden path first?
A dev/test Kubernetes cluster, a standardized workspace or a shared service can be detailed as a vertical product with SLO, security, recovery and a complete lifecycle.