Once it was running, we barely had to touch it.
Platform Engineering team, Global SaaS company
Both approaches can right-size Kubernetes. The difference is what it takes to get there and keep it running.
A homegrown stack, including VPA, Goldilocks, Robusta KRR, Prometheus, and custom scripts, can produce recommendations. Going from "recommendations" to "safe, continuous, and reliable production optimization" is where the effort actually goes: stitching tools together, writing the automation glue, and maintaining it as each component changes.
PerfectScale™ replaces that stack with one Helm chart. It's continuously optimizing within minutes, with resilience-aware guardrails, HPA-aware and code-revision-aware automation, and node-level visibility — none of which the open-source pieces do on their own, even combined.
Where a homegrown stack can genuinely get you vs. where the gap actually shows up.
PerfectScale™ installs as a one-line Helm chart and produces cost and resilience insight on day one. A DIY stack has to be assembled first: VPA for recommendations, Goldilocks to make VPA usable at scale, KRR to cross-check against Prometheus history, and custom scripts to turn any of it into action.
// SETUP
VPA and Goldilocks show what a container is requesting. They don't show what's wasted, what a rollout changed, or what a code revision did to resource usage. Prometheus can hold the raw metrics, but nothing in the open-source stack turns them into a forecast or an explanation.
// COST VISIBILITY
VPA lacks impact and context awareness, so every recommendation needs manual review before it's safe to apply. Nothing in the DIY stack flags a resilience risk before it becomes an incident — that's usually how it's found.
// RESILIENCE
Goldilocks makes VPA easier to browse, but someone still has to act on what it shows. PerfectScale™ closes that loop with policy-driven automation that's safe to run unattended, including configurable maintenance windows and GitOps/IaC integration.
// AUTOMATION
VPA, Goldilocks, and KRR all operate at the container level. None of them see node groups, idle node capacity, or how workload right-sizing should inform node choices — that's a separate problem a DIY stack typically leaves unsolved.
// NODE-LEVEL
Homegrown tools aren't free. They're paid for in engineering time, the most expensive resource a platform team has.
// TRUE COST
PerfectScale™ installs alongside an existing DIY stack with no disruption. A common pattern: keep Prometheus and existing dashboards for historical reporting while PerfectScale™ takes over live right-sizing and resilience automation — no migration required to start comparing results.
// EVALUATION PATH
A DIY stack is maintained by whoever on the team has bandwidth this sprint. PerfectScale™ includes a dedicated optimization specialist, and sits inside DoiT's broader Cloud Intelligence platform rather than standing alone as one more tool to operate.
// SUPPORT & PLATFORM
kubernetes network attribution
Network is often 20% or more of Kubernetes spend, and it's the part a DIY stack has no way to explain. VPA, Goldilocks, and KRR all operate on CPU and memory — none of them touch network cost. Cross-AZ replication, inter-cluster traffic, and NAT egress land as anonymous line items because nothing in the open-source stack puts a tag on a packet.
PerfectScale™ traces every traffic path to the customer and feature behind it. When cross-AZ cost jumps 27%, you see which feature caused it and which account to have the conversation with — instead of averaging the bill across everyone, which is what a Prometheus-only setup leaves you doing.
A practical comparison based on what each approach actually requires to operate and what it can see.
| Capability | PerfectScale™ | DIY / Homegrown |
|---|---|---|
| ARCHITECTURE & OPERATIONS | ||
| Installation | One-line Helm chart Single install, no cloud IAM changes required. | Multi-tool integration Requires wiring together VPA, Goldilocks, KRR, Prometheus, and custom scripts before any of it is useful. |
| Time to insight | Minutes Cost and resilience findings from the first scrape. | Weeks Only after the stack above is assembled and tuned. |
| Prometheus dependency | Independent Runs its own lightweight metrics agent. | Heavy dependency VPA, Goldilocks, and KRR recommendations are only as good as Prometheus's retention and query performance. |
| Ongoing maintenance | Fully managed Automatic updates, no engineering upkeep. | High Any Kubernetes, Prometheus, or tool release risks breaking CRDs, exporters, or scripts. |
| COST VISIBILITY & REPORTING | ||
| Cloud billing integration (AWS/GCP/Azure) | Native Connects directly to cloud billing APIs. | Manual integration effort Possible, but requires custom work to join Prometheus data with billing exports. |
| Workload-level cost allocation | Native Cost mapped to workload automatically. | Partial Goldilocks organizes VPA data by namespace, but mapping it to actual cost is still manual. |
| Ephemeral workload visibility (Spark, Jobs, ML) | Native Short-lived workloads are tracked and attributed. | Not available VPA and Goldilocks operate on steady-state containers; ephemeral jobs fall outside their model. |
| Wasted cost forecast | Native Quantifies savings left on the table before you act. | Not available No tool in the stack forecasts waste; you only see current requests versus usage. |
| Rollout and code-revision impact visibility | Native Flags cost and risk changes tied to a specific deploy. | Not available No concept of revision history in VPA, Goldilocks, or KRR. |
| Node group support and idle-space visibility | Native Surfaces idle node capacity by group. | Not available No concept of revision history in VPA, Goldilocks, or KRR. |
| Node group support and idle-space visibility | Native Surfaces idle node capacity by group. | Not available None of the four tools operate above the container level. |
| COST & PERFORMANCE OPTIMIZATION | ||
| Resource reduction strategy | Native Continuous, policy-driven recommendations. | Native (VPA) This is VPA's core function. |
| CPU and memory limit recommendations | Native Reverts to the previous valid request when capacity is unavailable. | Native (VPA) Also core VPA functionality. |
| Adaptive resiliency-aware policies | Native Recommendations weighted by OOM, throttling, and stability | Not available VPA has no impact or context awareness; every recommendation needs manual review before it's safe to apply. |
| Node-level optimization recommendations | Native Included by default. | Conditional Only if a node autoscaler is separately implemented and correctly configured. |
| RESILIENCE & RISK MANAGEMENT | ||
| Automated resilience risk detection | Native 30+ risk types continuously screened. | Not available Risks are typically discovered through production incidents, not flagged in advance. |
| Suspected memory leak indication | Native | Not available |
| HPA-aware optimization | Native Coordinates with the HPA to avoid conflicting changes. | Not available VPA is known to conflict with HPA when both target the same metric. |
| Autonomous resilience risk remediation | Native Acts on flagged risks automatically under policy. | Not available Remediation is manual. |
| AUTOMATION & INTEGRATION | ||
| Production-ready autonomous optimization | Native Safe to run unattended under policy. | Basic Custom scripts can apply changes, but with no built-in safety guardrails. |
| GitOps / IaC integration | Native Maps shared consumption to the business entity that generated it without tags. | Custom effort Possible, but you build and maintain the integration yourself. |
| Configurable maintenance windows | Native | Not available Timing of script runs is whatever you build (cron jobs, etc.), with no policy layer. |
| OPERATIONS & SUPPORT | ||
| Dedicated optimization specialist support | Included | High Requires deep expertise and continuous development to keep working. |
Decision guide
In evaluations where both platforms deliver similar savings, the deciding factors tend to be production stability, operational overhead after deployment, and confidence in the roadmap.
You have spare engineering capacity to dedicate for 6–12 months and ongoing after, your workloads are stable enough that manual VPA review is manageable, node-level and ephemeral-workload visibility aren't priorities, and you're comfortable owning the maintenance risk every time Kubernetes or Prometheus changes underneath you.
You want production-grade right-sizing without dedicating 1–2 FTEs to maintaining it, resilience risk detection matters as much as cost savings, you need visibility into ephemeral workloads, rollouts, and node groups that the open-source stack doesn't provide, and you'd rather get insight in minutes than after months of integration work.
Once it was running, we barely had to touch it.
Platform Engineering team, Global SaaS company
PerfectScale cut 40% off our total EKS spend, and the automations handle what used to take our team 20 hours a month. Now we spend that time on reliability and performance instead of chasing cost metrics.
Caio Cristo, Director of Infrastructure/SRE
PerfectScale allowed us to grow capacity without growing cost. We effectively absorbed 30% more usage for free.
Thomas Comtet, Senior Staff Engineer
I believed in the product the first time I saw it. I still show it to everyone. It was the only solution that combined smart automation with real cost savings, without putting performance at risk.
Joao Soares, Platform Engineering Lead
PerfectScale gave us the answers we needed on a silver platter. The insights saved us time and money.
Jason Berk, Platform Operator
It replaces what they do - CPU/memory recommendations plus the automation to act on them - but it can also run alongside your existing stack during evaluation. PerfectScale™ doesn't require VPA to function; its own read-only agent collects the signals it needs directly.
Typically 6–12 months of engineering effort to integrate the four tools plus custom scripts into something that produces safe, automated results across the cluster, plus 1 to 2 FTEs ongoing to keep it working as Kubernetes, Prometheus, and the tools themselves change versions.
No. PerfectScale™ runs its own lightweight metrics agent, so it's independent of Prometheus. A DIY stack built on VPA, Goldilocks, and KRR has a heavy dependency on Prometheus; if it's missing, misconfigured, or under-retained, the recommendations degrade with it.
PerfectScale™ continuously screens for 30+ risk types, including OOM kills, CPU throttling, under-provisioning, and suspected memory leaks, and prioritizes them alongside cost. VPA has no impact or context awareness, so it can't tell you a recommendation is risky before you apply it. Reviews must happen manually, and node- or HPA-related conflicts are typically found in production.
Yes. Install the PerfectScale™ Helm chart alongside VPA, Goldilocks, KRR, or Prometheus with no disruption to the cluster. A common pattern is to keep existing dashboards for historical reporting in week one, compare PerfectScale™'s recommendations against them, then expand automation at your own pace.
Beyond the initial 6–12 month build, plan on 1–2 FTEs of ongoing upkeep. Any Kubernetes, Prometheus, or tool release can break VPA CRDs, Prometheus exporters, or the custom scripts tying it together; someone has to notice and fix it. PerfectScale™ customers typically find another 30–60% in savings on top of what their DIY tooling had already captured, once that maintenance burden is removed.