Nov 28, Paris: AI Health Hack #2 with Alan, Qovery and AWS. Applications close Nov 21

Cross-Cloud GPU Spend Visibility in 2026: The Data, Tools and Controls That Make AI Costs Predictable

GPU bills get unpredictable when spend is split across AWS, Azure, GCP, OCI and neoclouds like CoreWeave or Nebius. Here is which providers export FOCUS billing data today, which tool does which job (OpenCost, Kubecost, Vantage, CloudZero, Finout, Cast AI, nOps), and the controls that stop GPU spend instead of just reporting it.

Mélanie Dallé
Senior Marketing Manager
NOV 21, 2026 · 19 MIN
Cross-Cloud GPU Spend Visibility in 2026: The Data, Tools and Controls That Make AI Costs Predictable

Key points:

  • Cross-cloud GPU spend visibility needs three layers, in this order: normalized billing data from every provider (FOCUS exports where they exist), a Kubernetes allocation engine that splits shared GPU nodes by workload (OpenCost, Kubecost, or a vendor agent), and a multi-cloud FinOps tool that joins both (Vantage, CloudZero, Finout, nOps). Skipping the first layer is why most GPU dashboards never reconcile with the invoice.
  • FOCUS coverage is real but uneven. AWS has a generally available FOCUS 1.2 export, Azure and Google Cloud have FOCUS 1.2 exports in preview, OCI publishes FOCUS cost reports, and among neoclouds Nebius exports FOCUS 1.2 while CoreWeave's FOCUS export is in preview and reports usage without dollar amounts.
  • GPU cost hides in five places that a normal cloud bill does not explain: idle GPUs that are allocated but not computing, prepaid reservations such as EC2 Capacity Blocks, neocloud invoices outside your hyperscaler bill, shared nodes, and GPUs sliced with MIG or time-slicing.
  • Controls make GPU spend predictable: budgets with actions or spend caps, requests.nvidia.com/gpu quotas per namespace, queue-based scheduling, and automatic shutdown of non-production GPU environments.
  • Where Qovery fits: on the clusters Qovery manages in your own cloud account, it gives every service and environment a consistent structure for cost allocation, runs GPU node pools, and auto-stops non-production environments on a schedule. It does not ingest neocloud invoices and does not replace a FinOps tool.

Qovery · Infrastructure control plane
Build with Claude Code, Deploy with Qovery
Learn more

Every AI team I talk to has the same month-end surprise. The GPU line on AWS went up, there is a CoreWeave or Nebius invoice nobody forecast, and the staging inference cluster ran all weekend on eight GPUs serving zero requests.

The FinOps Foundation's State of FinOps 2026 found that 98% of practitioners now manage AI spend, up from 31% two years earlier, across more than 1,100 respondents. And Cast AI's 2026 State of Kubernetes Optimization report measured average GPU utilization of 5% across the non-optimized clusters it analyzed. Put those together and you get the reason GPU bills feel random: almost everyone is now accountable for AI spend, and most of the GPU capacity they pay for does nothing.

This guide is about the plumbing that fixes it across several providers. If you want price-per-hour comparisons, I will point you to our GPU pricing comparison method instead. Here I stay on one question: what gives you cross-cloud GPU spend visibility, and what gives you control?

Why is GPU spend so hard to see across clouds?

GPU spend is hard to see because the bill records what you reserved, while the cost that hurts comes from what you did not use, and that gap is spread across several invoices in different formats. A hyperscaler bill tells you an instance ran for 720 hours. It does not tell you which team's pod held the GPU, whether a kernel ran on it, or that the same team also spends on a neocloud.

I find it helps to name the five places GPU cost hides, because each one needs a different fix.

1. Idle GPUs that are allocated but not computing. In Kubernetes, a pod that requests nvidia.com/gpu: 1 locks the whole device. Kubecost's GPU allocation model reads exactly that request (or the limit if no request exists), so allocation looks perfect even when the GPU sits idle. Utilization only shows up once you add NVIDIA's DCGM Exporter, which is what Kubecost 2.4 started using to compute idle GPU cost.

2. Reservations and capacity blocks. On AWS, EC2 Capacity Blocks for ML are charged up front when you reserve them, the payment appears in the month you purchased, and if the block starts in a later month the usage lands in a different billing month. AWS also states that Savings Plans and Reserved Instance discounts do not apply to Capacity Blocks. A team that books a two-week block in October for a November training run will see a spike in October and "free" GPUs in November unless someone amortizes it.

3. Neocloud invoices outside the cloud bill. CoreWeave, Nebius, Lambda and similar GPU clouds bill you directly. Their spend never appears in AWS Cost Explorer, Azure Cost Management or GCP Billing, so a dashboard built on hyperscaler data alone undercounts AI spend by exactly the share you moved to neoclouds to find capacity. Our post on where to find GPU capacity in 2026 explains why that share keeps growing.

4. Shared nodes. A GPU node also runs CPU sidecars, log agents, a gateway and sometimes a CPU-only pod that landed there because nothing prevented it. Somebody has to decide how the node's idle and overhead cost is split, and every tool has a different default.

5. MIG and time-slicing. NVIDIA's own GPU sharing docs explain that a GPU configured with four time-slicing replicas advertises four separate nvidia.com/gpu resources, and that "time-slicing trades the memory and fault-isolation that is provided by MIG for the ability to share a GPU by a larger number of users." Multi-instance GPU on GKE can divide one supported GPU into up to seven slices. If your cost tool counts each replica or slice as a full GPU, your allocated GPU-hours exceed what you were billed.

Where GPU cost hidesWhat the bill showsWhat you need to see itTypical fix
Idle allocated GPUsInstance hours, fully billedAllocation from nvidia.com/gpu requests plus DCGM utilizationRightsize, scale to zero, auto-stop non-production
Capacity Blocks and reservationsOne upfront charge in the purchase monthAmortization across the reservation window, used vs unused linesAmortize in your FinOps tool, track unused reservation time
Neocloud invoicesNothing on the hyperscaler billA separate billing feed (FOCUS export or API) in the same toolIngest neocloud data next to AWS, Azure, GCP and OCI
Shared GPU nodesOne node costA rule for splitting idle and overhead cost per workloadTaint GPU nodes, pick an idle-cost split rule
MIG and time-slicingOne physical GPUFractional GPU-hours per slice or replicaUse a tool that reports fractions, or allocate by utilization

What is the data layer for cross-cloud GPU cost, and which providers support FOCUS?

The data layer is a normalized billing dataset from every provider you pay for GPUs, and in 2026 the closest thing to a standard is FOCUS, the FinOps Open Cost and Usage Specification from the FinOps Foundation. FOCUS defines common columns (billed cost, effective cost, charge category, commitment fields, SKU, resource ID, tags) so an H100 hour on AWS and an H100 hour on a neocloud land in the same table without custom mapping.

The current version is FOCUS 1.4, ratified on June 4, 2026. It adds Invoice Detail and Billing Period datasets for reconciling usage to invoices, and expands the Contract Commitment dataset from 13 to 30 columns. Commitment data matters for GPUs because so much GPU spend is committed or prepaid. The FinOps Foundation also says per-token AI model fields are planned for FOCUS 1.5, not 1.4.

Providers ship older versions than the spec, so check what each one actually exports before you design anything. Here is what I could verify this month from the providers' own pages and the FOCUS adopter list:

ProviderFOCUS exportStatusWhere the data lands
AWSFOCUS 1.2 (also 1.0)Generally available since November 2025S3 via AWS Data Exports ("FOCUS 1.2 with AWS columns"), hourly, daily or monthly granularity
Microsoft AzureFOCUS 1.2-previewPreview, 94% conformance scoreStorage account via Cost Management exports
Google CloudFOCUS columns up to 1.2PreviewBigQuery table gcp_billing_export_focus_<BILLING_ACCOUNT_ID>
Oracle Cloud (OCI)FOCUS cost reports (listed as 1.3 by the FinOps Foundation)Available since June 2024CSV reports in an Oracle-owned bucket, generated every six hours
NebiusFOCUS 1.2 plus Nebius extensionsAvailableHourly export to an Object Storage bucket, from the console or API
CoreWeaveFOCUS usage exportPublic preview, reports raw usage, not dollarsPulled by API; your tool applies list or negotiated rates

Two things in that table change how I would build the pipeline.

First, two FOCUS exports can still disagree. Azure is still at 94% conformance and GCP's export is in preview, so test the columns you depend on (commitment and tag columns especially) against each export before you trust a cross-cloud join.

Second, CoreWeave's export has usage but no cost. Vantage's integration, launched in public preview on November 12, 2026, computes cost as billable usage times the rate for each SKU, defaults to CoreWeave's public list prices, and lets you enter your negotiated rates. If you have a committed contract with a neocloud, the rate card is part of your data layer. Keep it in version control.

For providers with no FOCUS export, use the provider's billing API, a CSV upload into your FinOps tool, or a monthly manual line from the invoice. The manual line is fine for a small provider and risky for the one where your training runs live.

Which tools give cross-cloud GPU spend visibility, by job?

No single tool does every job well, so pick by job: OpenCost or Kubecost for allocation inside Kubernetes, a multi-cloud FinOps platform (Vantage, CloudZero, Finout, nOps) to join every bill, and a GPU-aware optimizer such as Cast AI if you want automation that changes the cluster. I covered the general FinOps tool landscape in our FinOps tools roundup, so this section only looks at the GPU-specific behavior.

ToolPrimary jobGPU allocation basisNeocloud coverage (verified)Shared or sliced GPUsChanges infrastructure?
OpenCostKubernetes allocation, open source (CNCF incubating)GPU requests, with utilization support; per-model inference cost with llm-d and vLLM since 1.121.0Runs in any cluster, including neocloud KubernetesDepends on how the device plugin advertises GPUsNo
Kubecost (IBM)Kubernetes allocation and savingsnvidia.com/gpu request or limit, plus DCGM utilization and idle cost since 2.4Runs in any clusterNot documented for MIG or time-slicing in its allocation pageNo (recommendations only)
AWS Split Cost Allocation Data for EKSNative EKS allocation in CURAccelerator reservations (NVIDIA, AMD, Trainium, Inferentia)AWS onlyReservation-basedNo
VantageMulti-cloud FinOpsKubernetes agent with DCGM metrics, GPU idle costCoreWeave FOCUS import (preview); agent on DigitalOcean, CoreWeave, Nebius clustersFractional MIG accounting (AWS and Azure, single strategy)No
CloudZeroMulti-cloud FinOps and unit costGPU requests weighted with CPU and memory, idle overhead distributedAnyCost API to push any provider's dataRequest-basedNo
FinoutMulti-cloud FinOps (MegaBill)Shared cost reallocation for GPU nodesNeoclouds not listed in its AI integrations page; askReallocation rulesNo
nOpsMulti-cloud FinOps and commitment managementKubernetes and GenAI cost viewsNot verified for neocloudsNot documentedPartly (commitment management)
Cast AIGPU-aware optimization and autoscalingWorkload, team and app level GPU costCross-cloud GPU sourcing through its OMNI ComputeTime-slicing (1-48 replicas) and MIG attributionYes

Kubernetes allocation: OpenCost and Kubecost

Use OpenCost or Kubecost inside every cluster that runs GPUs, because only an in-cluster engine knows which pod held which GPU. Cloud bills stop at the node.

OpenCost moved to CNCF incubation in October 2024 and is free. Its 1.121.0 release in August 2026 added llm_total_hourly_cost and llm_cost_per_million_tokens metrics for models served with llm-d and vLLM, with an allocation-based view that reconciles with your bill and a usage-based view that counts only active inference. OpenCost also has a plugin framework for external costs such as OpenAI, Datadog and MongoDB Atlas. It does not ingest a CoreWeave invoice for you.

Kubecost adds a UI, savings recommendations and multi-cluster rollups on top of the same model. Because it allocates from the nvidia.com/gpu request, it answers "who reserved the GPU" accurately. Pair it with DCGM to answer "who used it."

On EKS specifically, AWS added accelerator support to Split Cost Allocation Data in September 2025, so CUR 2.0 can split GPU, Trainium and Inferentia node cost by pod reservation without an extra tool. That only covers AWS, which is the problem this whole article is about.

Multi-cloud FinOps: Vantage, CloudZero, Finout and nOps

Use a multi-cloud FinOps platform to join hyperscaler FOCUS exports, neocloud data and Kubernetes allocation in one place, and pick it based on which of your GPU providers it can actually ingest. That last test eliminates more candidates than any feature list.

  • Vantage has the most neocloud-specific work I could verify. Its Kubernetes agent computes GPU idle costs from DCGM memory metrics, it extended GPU support to DigitalOcean, CoreWeave and Nebius clusters in February 2026, and in October 2026 it shipped fractional MIG accounting, where "a pod holding one device for an hour reports 0.5 physical GPU-hours instead of 1.0, and the remaining 0.5 shows up as idle capacity."
  • CloudZero attributes GPU requests to workloads alongside CPU and memory from agent v1.2.0, and its Kubernetes allocation spreads shared node cost, including idle overhead, across workloads. For providers without a native connector, AnyCost lets you push cost data through an API. Its strength is unit cost (cost per training job, per customer, per inference).
  • Finout puts everything in a single view it calls MegaBill and has shared cost reallocation for GPU nodes where tags cannot split cost. Its FinOps for AI page lists Bedrock, Vertex AI, Azure OpenAI, OpenAI, Anthropic and others, but no neocloud, so confirm coverage for your GPU provider before you sign.
  • nOps covers AWS, Azure, GCP, Kubernetes, GenAI platforms and SaaS in one view and is strongest on AWS commitment management. I could not confirm neocloud ingestion on its public pages.

GPU-aware optimization: Cast AI and friends

If you want a tool that changes the cluster (packs GPUs, turns on time-slicing, picks cheaper capacity) rather than one that reports, look at GPU-aware optimizers like Cast AI. Cast AI's GPU cost visibility reports cost by workload, team and application, and it supports time-slicing through node templates and MIG, attributing cost to the workload that used each share. The trade-off is that an optimizer takes write access to your node provisioning, which some platform teams will not grant.

If your GPU fleet spans several clouds and you also need one place to see what is deployed where, read Alessandro's 3-layer stack for multi-cloud Kubernetes observability. This article only covers the GPU-cost slice of that picture.

Stop paying for GPUs nobody is using.
Qovery runs your AI services on Kubernetes in your own AWS, GCP, Azure or Scaleway account, or your existing cluster, with GPU node pools, per-environment structure and auto-stop for non-production environments. Start free in minutes.

How should you allocate a shared or sliced GPU fairly?

Allocate by reservation for chargeback and by utilization for optimization, and never count a MIG slice or time-slicing replica as a whole GPU. Reservation-based allocation is what you can defend to a team ("you held it, you pay for it"). Utilization-based allocation is what tells you where to cut.

Here is the rule set I use with teams sharing GPU nodes:

  • Dedicated GPU per pod. Charge the full GPU to the pod that requested it. Report utilization next to it so the team sees its own idle cost.
  • MIG slices. Charge the fraction of the physical GPU that the slice represents. A 1g.10gb slice on an 80 GB A100 is one seventh of the card. Vantage does this automatically for MIG on AWS and Azure; with OpenCost or Kubecost, check how your device plugin names MIG resources before you trust the numbers.
  • Time-slicing replicas. Charge each replica 1/N of the GPU, where N is the replica count. Time-slicing gives no memory or fault isolation, so if two tenants share a replica pool, expect disputes and split by measured utilization instead.
  • Idle and overhead on GPU nodes. Pick one rule and write it down: spread idle cost proportionally to GPU requests, or put it in a platform cost center. I prefer the platform cost center for the first quarter, because it makes the idle number visible instead of hiding it inside every team's bill.
  • Prepaid capacity. Amortize Capacity Blocks and committed neocloud contracts across the reservation window, then show used versus unused time. AWS already gives you separate bill lines for used and unused reservation time.

A NoSchedule taint on GPU node pools keeps CPU pods off them, which removes most "why is my team paying for an H100" tickets.

What controls make GPU spend predictable?

Four controls turn a GPU dashboard into a predictable bill: budgets that act, quotas that cap what can be requested, scheduling that queues work instead of adding nodes, and automatic shutdown of non-production GPU environments. Visibility tells you what happened last week. These decide what can happen next week.

Budgets that do something

Most cloud budgets only send email. The details differ by provider:

  • AWS Budgets can run budget actions automatically or after approval: apply an IAM policy or a service control policy, or target specific EC2 or RDS instances. A deny policy on GPU instance families at 90% of forecast is a reasonable guardrail for research accounts.
  • Google Cloud budgets alert by default, but spend caps became generally available on October 31, 2026. They pause pay-as-you-go and CUD-covered usage for a project or service within minutes of the breach, without deleting resources. Provisioned Throughput is never halted, so do not count on a cap to stop reserved capacity.
  • Neoclouds each have their own controls, and a FinOps tool's budget only alerts on them. Treat neocloud budgets as alerting plus a human decision.

Quotas that cap what can be requested

Kubernetes supports quotas on extended resources. The ResourceQuota docs give the exact form: requests.nvidia.com/gpu: 4 limits a namespace to four requested GPUs, and only the requests. prefix is allowed for extended resources. One namespace per team (or per environment) with a GPU quota is the cheapest control you will ever deploy.

Cloud-level GPU quotas are a second, coarser cap. They exist to protect provider capacity, but they also stop a misconfigured autoscaler from buying 64 GPUs at 3 AM.

Scheduling instead of scaling

When several teams share GPUs, a queue beats an autoscaler for cost. Kueue admits jobs against per-team quotas and lets idle quota be borrowed, so training jobs wait for capacity instead of triggering new nodes. We walk through that setup in fair GPU sharing across teams with Kueue.

Auto-stop for non-production GPU environments

The fastest GPU saving for most teams is shutting down development, staging and preview environments that hold GPUs outside working hours. A staging inference stack on GPUs that runs nights and weekends pays for roughly 128 idle hours out of the 168 hours in a week if the team only uses it 8 hours a day on weekdays. That arithmetic is the same on every cloud and every neocloud.

Make it a platform rule, because cron jobs get forgotten. Then make sure the node pool scales down when the pods stop, otherwise you stopped the app and kept paying for the GPU.

Where does Qovery fit, and where does it not?

Qovery fits as the deployment and control layer for the Kubernetes clusters it manages in your own cloud account: it gives every GPU service and environment a consistent structure for cost allocation, runs GPU node pools, and stops non-production environments on a schedule. It does not read neocloud invoices, does not produce a cross-provider GPU bill, and does not replace Vantage, CloudZero, Finout, nOps, Kubecost or OpenCost.

Qovery is an Agentic DevOps platform. Your services run on Kubernetes in your own AWS, GCP, Azure or Scaleway account, or on a Kubernetes cluster you already run, so the GPU bill, reservations and committed-use discounts stay in your name. Here is what that gives the GPU cost stack, concretely:

  • Cost structure by construction. Every service lives in an organization, project and environment, so "which environment holds these GPUs" has an answer before anyone writes a label policy. Qovery applies system tags (cluster and organization IDs, region) to the cloud resources it provisions, including Karpenter nodes on AWS, for traceability and cost allocation.
  • Per-environment cost visibility with Kubecost. Qovery integrates with Kubecost, and each Qovery environment runs in its own Kubernetes namespace, so Kubecost's namespace view reads as GPU cost per environment on the clusters Qovery manages.
  • GPU node pools and a GPU count per service. On Qovery-managed clusters you enable a dedicated GPU node pool, choose the GPU instance types and spot settings, and set the number of GPUs on each service, with Karpenter provisioning nodes on AWS. GPU nodes stay separate from the rest of the cluster.
  • Auto-stop for non-production. Deployment rules auto-stop and auto-start environments by day and timezone, matched by name pattern such as dev-*, and preview environments are deleted when the pull request closes. This is the control from the previous section, applied as a platform rule.
  • Agents with scoped access. AI coding agents operate through Qovery Agent Skills and the MCP Server, with API Policy Tokens limiting what each agent can do and every action attributed in the audit log, so an agent cannot quietly scale a GPU service to eight replicas without leaving a trace.

If your GPU spend sits on CoreWeave, Nebius or Lambda in clusters Qovery does not manage, or arrives as a prepaid contract invoice, you need a FinOps tool to bring that data in. Qovery makes the Kubernetes side of your GPU spend easier to allocate and easier to stop. The cross-provider join belongs to Vantage, CloudZero, Finout or nOps. For the bigger picture of running AI workloads this way, see our Kubernetes for AI topic page.

What does a 30-day setup for cross-cloud GPU cost control look like?

A small platform team can get a reconciled cross-cloud GPU view and the four controls in place in about 30 days, if it builds the data layer first and the dashboards last. This is the order I would follow.

WeekGoalConcrete stepsDone when
1Data layerTurn on AWS FOCUS 1.2 export, Azure FOCUS 1.2-preview export, GCP FOCUS BigQuery export, OCI FOCUS reports, Nebius FOCUS export; list every neocloud contract and its rate cardEvery GPU provider has a feed or a documented manual line
2AllocationInstall OpenCost or Kubecost (or a vendor agent) plus DCGM Exporter in every GPU cluster; taint GPU nodes; pick the idle-cost ruleAllocated GPU-hours reconcile to billed GPU-hours within a few percent
3JoinConnect feeds and agents to one FinOps tool; amortize Capacity Blocks and commitments; tag by team, service, environmentOne report shows GPU spend by team across every provider
4Controlsrequests.nvidia.com/gpu quotas per namespace, budget actions on AWS, spend caps on GCP, Kueue for shared training, auto-stop on non-production GPU environmentsNext month's GPU forecast lands within your tolerance

The "done when" column in week 2 is where most projects stall. If allocated GPU-hours are higher than billed GPU-hours, you are probably counting MIG slices or time-slicing replicas as full GPUs. If they are lower, you have GPU nodes running with no GPU pods, which is the idle cost you came here to find.

How do I do this with Qovery from Claude Code or Cursor?

Install the Qovery Agent Skills, then ask your coding agent in plain language to review GPU spend and set auto-stop on non-production environments. The agent proposes changes and you approve them before anything is applied.

BASH|1. Agent Skills for Claude Code, Cursor, Codex, OpenCode, Gemini CLI (one install)
curl -fsSL https://skill.qovery.com/install.sh | bash

# 2. MCP Server for Claude Code, read-only by default (OAuth sign-in in your browser)
claude mcp add --transport http qovery https://mcp.qovery.com/mcp --callback-port 4242
  • The first command installs the skills, including qovery-optimize, which analyzes resource usage across your clusters and proposes right-sizing, spot capacity and environment schedules. It asks before it changes anything.
  • The second command connects the read-only MCP Server, so the agent can inspect clusters, environments and services. You approve the OAuth sign-in in your browser.
  • Write access is a separate, explicit opt-in: claude mcp add --transport http qovery "https://mcp.qovery.com/mcp?read_write=true" --callback-port 4242, which also needs write access enabled in the Qovery Console. Only add it if you want the agent to apply schedules itself.

Then ask, for example: "Find the non-production environments with GPU services and propose an auto-stop schedule for weekday business hours." Setup guides live at the AI agent quickstart and the Claude Code integration page.

Frequently asked questions
What actually gives cross-cloud GPU spend visibility and control when AI usage grows across providers?

Three layers give visibility: FOCUS billing exports from each provider, an in-cluster allocation engine such as OpenCost or Kubecost with DCGM utilization, and a multi-cloud FinOps tool such as Vantage, CloudZero, Finout or nOps that joins them. Control comes from budget actions or spend caps, requests.nvidia.com/gpu quotas, queue-based scheduling with Kueue, and automatic shutdown of non-production GPU environments.

Which cloud and GPU providers support FOCUS billing exports in 2026?

AWS has a generally available FOCUS 1.2 export, Azure has a FOCUS 1.2-preview export, Google Cloud has a FOCUS export to BigQuery in preview, and OCI publishes FOCUS cost reports. Among GPU clouds, Nebius exports FOCUS 1.2, and CoreWeave has a FOCUS usage export in public preview that reports usage without dollar amounts.

Why does my GPU cost report not match my cloud invoice?

The usual causes are MIG slices or time-slicing replicas counted as whole GPUs, GPU nodes running with no GPU pods, and prepaid capacity such as EC2 Capacity Blocks charged up front in the purchase month. Amortize reservations, report fractional GPU-hours for slices, and track idle node cost separately.

Can OpenCost or Kubecost track neocloud GPU spend?

Both run inside any Kubernetes cluster, including clusters on CoreWeave or Nebius, so they allocate the GPU nodes they can see by workload. Neither turns a neocloud invoice or a prepaid contract into a cost feed for you, so you still need a FinOps tool or a custom import for that part.

Does Qovery replace a FinOps tool for GPU costs?

No. Qovery gives the clusters it manages in your own cloud account a consistent environment and service structure, Kubecost integration, GPU node pools and auto-stop for non-production environments. It does not ingest neocloud invoices or build a cross-provider bill, so teams pair it with Vantage, CloudZero, Finout, nOps, Kubecost or OpenCost.

Mélanie Dallé
About the author
Mélanie Dallé

Melanie leads content at Qovery. She covers platform engineering trends, Kubernetes operations, FinOps, and the tools that help engineering teams ship faster.

Next step

Stop paying for GPUs nobody is using.

Qovery runs your AI services on Kubernetes in your own AWS, GCP, Azure or Scaleway account, or your existing cluster, with GPU node pools, per-environment structure and auto-stop for non-production environments. Start free in minutes.