Internal developer platform
A curated self-service layer that lets product teams build and operate software without mastering every infrastructure subsystem.
Explore the systems, practices, and tools that turn infrastructure into a dependable product.
GRAPH SCOPE
95 nodes
7 operating clusters, from developer experience to AI governance. Curated for production teams, not alphabetical completeness.
Search aliases, sources, tools, or practices. Filters and production journeys narrow the graph and index together.
Select any node for a practical definition, operating context, adoption signal, and deeper explanation.
Arrowed, typed lines explain what enables, governs, secures, observes, or measures the selected node.
Trace a production journey
All platform capabilities and controls.Relationship map
Tab into the map, then use the arrow keys, Home, or End to move between nodes; each one is inspected as it receives focus. Drag to pan and use the zoom controls, or Control or Command with the scroll wheel, to change scale. Edges point from the selected node toward related capabilities and use line style to identify the relation type.
Searchable index
A curated self-service layer that lets product teams build and operate software without mastering every infrastructure subsystem.
Operating an internal platform with defined users, outcomes, discovery, roadmap, and adoption metrics.
Supported, opinionated routes for common tasks such as creating, deploying, and observing a service.
Well-supported technology choices that teams are encouraged, but not always forced, to use.
A searchable interface for ownership, documentation, templates, dependencies, and operational actions.
An open-source framework for developer portals, software catalogs, documentation, and templates.
Letting engineers complete approved platform actions on demand through automated interfaces.
The information and decision-making capacity engineers must hold to deliver and operate a system.
A model for organizing stream-aligned, platform, enabling, and complicated-subsystem teams around fast flow.
A structured inventory of software components, owners, dependencies, lifecycle state, and operational metadata.
Two distinct declarative infrastructure-as-code projects that share HCL workflows and much of the provider ecosystem.
Infrastructure as code using TypeScript, Python, Go, C#, and other general-purpose languages.
A Kubernetes control-plane framework for composing and continuously reconciling cloud resources.
Preconfigured cloud foundations for identity, networking, logging, policy, account structure, and cost controls.
Expressing and testing governance rules in versioned, executable policy.
Replacing deployed infrastructure artifacts instead of modifying them in place.
Finding differences between declared infrastructure or configuration and actual running state.
Controlling the creation, storage, distribution, rotation, and revocation of credentials.
A tool that estimates cloud cost changes from Terraform and OpenTofu plans.
Operating declarative systems from versioned, immutable desired state that software agents automatically pull and continuously reconcile.
A Kubernetes GitOps controller with application health, synchronization, drift detection, and rollback visibility.
Composable Kubernetes GitOps controllers for sources, manifests, Helm releases, and image automation.
Releasing changes to increasing portions of traffic while evaluating health and business signals.
Sending a small share of traffic to a new version before wider promotion.
Restoring a known-good application, configuration, model, or infrastructure state after a failed change.
Protecting the integrity and provenance of source, dependencies, builds, artifacts, and deployment inputs.
A machine-readable inventory of software components and dependencies in an artifact.
A declarative orchestration system for scheduling and operating containerized workloads across clusters.
A standard interface used by container runtimes and Kubernetes to configure workload networking.
A dedicated layer for service-to-service traffic policy, identity, telemetry, and resilience.
Controllers that encode domain-specific lifecycle logic behind Kubernetes custom resources.
Adjusting workload capacity in response to demand, schedules, or predictive signals.
Allocating scarce accelerator capacity with placement, sharing, priority, and quota controls.
A Kubernetes-native model serving system with standardized inference resources, autoscaling, and rollout capabilities.
Giving software workloads short-lived, verifiable identities instead of static credentials.
The ability to understand a system’s internal state from the telemetry and context it emits.
A vendor-neutral standard and toolkit for producing, collecting, and exporting traces, metrics, and logs.
An SLI measures user-relevant behavior; an SLO defines the acceptable target over a time window.
The allowed amount of unreliability implied by a service level objective.
Following a request through multiple services and operations using shared trace context.
A coordinated process for detecting, containing, resolving, and learning from production disruption.
Manual, repetitive, automatable operational work that scales with service growth and creates little enduring value.
A controlled inventory of model versions, metadata, lineage, evaluation results, and promotion state.
An open-source platform for experiment tracking, model packaging, evaluation, and registry workflows.
A system for defining, discovering, computing, and serving reusable machine-learning features.
Automated criteria that block model, prompt, or retrieval changes unless quality and risk checks pass.
A controlled ingress for model calls that centralizes routing, authentication, budgets, policy, and telemetry.
Grounding model responses with information retrieved from an external knowledge source at request time.
Versioned controls that constrain model inputs, outputs, tool use, and policy-sensitive behavior.
A database or index optimized for similarity search over embedding vectors and metadata.
An open-source inference engine optimized for high-throughput serving of large language models.
A cross-functional practice that makes cloud and AI value, cost, and ownership visible and actionable.
Assigning infrastructure and service spend to accountable teams, products, environments, or workloads.
The FinOps Open Cost and Usage Specification version 1.2, a normalized schema for billing data.
Policies and systems that authenticate identities and authorize actions on resources.
An engineering implementation pattern for collecting traceable artifacts about how an AI system was designed, evaluated, changed, monitored, and overseen.
Detecting and removing or transforming personal information before it reaches unauthorized systems.
A trace of how data moves and changes from source to model, report, or application.
Encoding controls, evidence requirements, and decision rules into versioned automation.
A reusable outcome that the platform exposes to internal customers, such as deploying a service or obtaining a cloud account.
Measures that show whether platform capabilities improve developer flow, reliability, adoption, and satisfaction.
An explicit contract describing a team’s ownership, responsibilities, services, communication paths, and interaction expectations.
A stable programmatic contract through which teams request and manage platform capabilities.
A transparent set of checks that evaluates whether a service meets agreed operational standards.
On-demand creation of policy-compliant, observable, and disposable application environments.
Automated creation of cloud accounts, subscriptions, or projects from an approved landing-zone baseline.
Frequent integration of small changes into a shared branch with automated build and verification feedback.
Verifiable information about where, when, and how a software or model artifact was produced.
Cryptographically binding an identity to an artifact digest so consumers can verify who approved or produced it.
A signed statement that makes a claim about an artifact, such as its provenance, test result, or policy review.
Assessing whether third-party components are maintained, secure, governable, and replaceable enough for production use.
Runtime controls that separate code deployment from feature exposure.
A role-oriented Kubernetes API for expressing service networking and traffic routing.
A Kubernetes API framework for requesting, preparing, and sharing specialized hardware through resource claims.
A Kubernetes-native job queueing controller for quota, admission, priority, and resource sharing.
Using Linux eBPF programs for programmable networking, security policy, and telemetry close to the kernel.
Safely sharing Kubernetes cluster resources among teams or workloads with different trust and isolation needs.
Alerting on how quickly a service consumes its error budget across multiple time windows.
The collection, processing, routing, redaction, sampling, and export path for traces, metrics, and logs.
Choosing whether to retain a trace after enough of the complete trace is available for a policy decision.
Controlled experimentation that tests system behavior under realistic failure conditions.
Restoring critical services and data after a large-scale or long-duration failure.
A versioned system of record for prompts, templates, model settings, evaluation evidence, and promotion state.
A traffic-management layer optimized for routing inference requests across model-serving backends.
Continuous measurement of model quality, drift, operational health, and business impact after deployment.
Automated checks that block data or model pipeline progression when data contracts or quality thresholds fail.
The runtime control layer around an AI agent’s model calls, tools, state, approvals, evaluation, and telemetry.
Measuring technology cost against a meaningful product unit such as an active customer, successful task, or inference.
An owned register of AI systems, models, purpose, risk context, data, providers, dependencies, and lifecycle state.
Designed points where qualified people can understand, intervene in, override, or stop an AI-supported process.
Ongoing collection and review of production performance, incidents, complaints, and emerging risks after an AI system is deployed.
Controls for approving, authenticating, scoping, monitoring, and retiring Model Context Protocol servers and tools.
Detecting, assigning, investigating, and correcting unexpected changes in cloud or AI spend.
A specification for expressing the carbon emissions rate of a software system per functional unit.
An open standard for emitting lineage events about jobs, runs, datasets, and their relationships.
Adoption signals show a sensible default for mid-market production teams. Your constraints, workload, and operating capacity still determine the right route.
Platform foundations
16 nodes. Product, team, and experience principles that make a platform useful.
Infrastructure and IaC
10 nodes. Repeatable environments, policy boundaries, identity, and infrastructure lifecycle.
Delivery and GitOps
14 nodes. Safe, observable paths from source control to production.
Kubernetes and runtime
13 nodes. Workload scheduling, networking, scaling, and production execution.
Observability and SRE
12 nodes. Signals, objectives, and operating practices for dependable systems.
MLOps and LLMOps
14 nodes. Release, evaluate, serve, and govern models and AI applications.
FinOps, security, and governance
16 nodes. Cost, access, evidence, and controls that keep platforms accountable.