6 Practical Ways to Reduce Your GCP Costs

Running workloads in Google Cloud Platform (GCP) gives you powerful infrastructure, but costs can add up quickly if you're not careful. Here are six actionable strategies I personally use to keep my GCP bill under control.

Leverage Committed Use Discounts Wisely

GCP offers two types of Committed Use Discounts (CUDs): spend-based and resource-based.

• Spend-based CUDs are simpler to manage—you commit to spending a fixed amount on specific services (like Compute Engine or Cloud SQL), and GCP gives you a discount across eligible usage.

• Resource-based CUDs offer deeper discounts but require more granular commitments, such as committing to specific machine types (e.g., n2-standard-4 in a specific region). These are best suited for stable, predictable workloads where you can plan resources in advance.

For example, spend-based CUDs can offer up to 46% discount if bought over 3 years and resource-based CUDs can be expected to generally offer 55% discount.

Committed Use Discounts (CUDs) function like a prepaid contract: you commit to using $1,000 worth of CPU and memory monthly for 3 years, and in return, you get a steep discount—paying only $540/month. But there's a catch: if you only use $500 worth of resources, you'll still pay the full $540 each month, regardless of actual usage.

Audit Your Logs and Exclude What You Don’t Need

Cloud Logging is essential, but it can become a silent budget killer if left unchecked. Open up Cloud Logging and start analyzing:

• First, ensure you're excluding the _Required sink, which contains ADMIN_WRITE audit logs. These are provided for free by GCP.

• Then, analyze your log volumes by type and source. Applications often log excessively, especially at verbose levels, which can lead to significant costs.

• Use log exclusions at the Log Router level to filter out unnecessary logs and keep only what provides value.

💡 GCP provides 50 GiB of free logging storage per project per month. To take advantage of this, consider organizing your services into separate projects—for example, one project for your database, another for the backend, etc. This approach not only helps reduce logging costs but also simplifies IAM management. It's much easier to grant permissions at the project level than to manage conditional or resource-level IAM policies, which can be more complex and error-prone.

Shut Down Idle VMs and Node Pools Overnight

If you're running development, staging, or batch workloads, there's often no need to keep them running 24/7. Automatically shutting them down during off-hours can lead to significant savings.

Cloud Scheduler makes this easy — no scripting required. You can configure it to call GCP APIs on a schedule to scale down resources.

✅ Example: Scale Down a GKE Node Pool

Set up a Cloud Scheduler job to send a POST request to the GKE API:

POST https://container.googleapis.com/v1/projects/YOUR_PROJECT/zones/YOUR_ZONE/clusters/YOUR_CLUSTER/nodePools/YOUR_NODE_POOL/setSize
Body: {
  "nodeCount": 0
}
Auth: Service account with GKE edit permissions

✅ Example: Pause a Cloud SQL Instance

Use Cloud Scheduler to send a PATCH request to the SQL API:

PATCH https://www.googleapis.com/sql/v1beta4/projects/YOUR_PROJECT/instances/YOUR_INSTANCE
Body: {
  "settings": {
    "activationPolicy": "NEVER"
  }
}
Auth: Service account with Cloud SQL Admin role

You can also reverse the change in the morning by scheduling a second job that sets activationPolicy back to "ALWAYS" or scales your node pool back up.

💡 This approach works the GCP Web UI or terraform. Just create a scheduler job, choose HTTP target, and set the API call, body, and auth settings accordingly.

Consolidate Load Balancers with an Ingress Controller

Every load balancer adds cost, so running one per GKE service quickly becomes expensive.

• Deploy an NGINX Ingress Controller in your Kubernetes clusters to consolidate multiple services behind a single Layer 7 HTTP load balancer.

• It handles routing based on hostname or path, reducing the need for multiple external LBs.

💡 This is particularly effective for internal apps or APIs accessed behind a gateway. I leveraged this approach in previous blog posts : https://blog.tauveron.com/achieving-zero-trust-access-on-gcp-with-azure-ad-iap-and-nginx-ingress and https://blog.tauveron.com/deploying-traefik-in-gke-using-the-google-https-load-balancer-l7.

Use Spot Instances for Non-Critical Workloads

Spot VMs offer up to 91% discounts compared to standard instances, but they can be preempted at any time.

• Perfect for CI/CD runners, dev environments, batch jobs, or anything fault-tolerant.

• Use smaller instance types to avoid capacity issues—Google has more availability in lower-size SKUs.

• Spot instances work well in GKE because GKE takes care of node pool autoscaling. For plain VMs, consider a managed instance group to automatically restart the VM if it gets preempted.

💡 Combine spot instances with automation to gracefully handle preemption.

Understand the Cost Tradeoffs of Serverless Platforms

GCP’s serverless products like Cloud Run and GKE Autopilot are powerful—but not always cost-effective.

• Cloud Run is great for short-lived tasks and web services that can scale to 0. If your workload is infrequent, it can be extremely efficient.

• GKE Autopilot is a good fit for spiky, unpredictable workloads where you benefit from rapid scaling. But for long-running workloads, it becomes really expensive compared to managing your own nodes.

💡 Measure actual usage patterns before deciding between serverless and self-managed.

Final Thoughts

Cloud optimization isn't just about cutting costs—it's about making smarter architectural and operational choices. By applying the strategies outlined above, I reduced my company’s annual GCP spend by over 30%.

Here’s what made the biggest difference:

• 💡 Consolidating load balancers with an Ingress controller cut networking overhead by more than 5%.

• 🧾 Fine-tuning log ingestion and storage policies saved us an additional 3–4%.

• 📉 Leveraging 3-year Committed Use Discounts for stable workloads led to savings of over 20% on compute costs.

These aren't theoretical optimizations—they're practical changes with real results. Whether you're managing a small team or a large-scale production environment, regularly auditing your cloud usage and spending can yield substantial, ongoing returns.