A clear guide to free virtual machines, serverless containers, functions, app hosting, Kubernetes, and development environments – plus the limits that can still create a bill.

Short answer: The best Google Cloud free compute option depends on the workload. Use Compute Engine for a small always-on server, Cloud Run for bursty containers, Cloud Run functions for event-driven code, and App Engine Standard for a managed application. New customers can also test larger configurations with the $300 Free Trial credit.

“Free” means two different programs

Google Cloud offers a time-limited trial credit and recurring Free Tier allowances. Understanding that distinction is the first step toward choosing the right service and avoiding unexpected charges.

The Free Trial gives new customers room to experiment

Eligible new customers receive $300 in Welcome credit for 90 days. The credit can cover many Google Cloud products, including configurations that are larger than the recurring free allowances. Google says Free Trial accounts are not billed automatically; charges begin only after the account is upgraded to a paid billing account.

The trial is useful for proofs of concept, performance tests, and short projects. It is not a permanent hosting plan. If the credit is exhausted or the 90-day period ends without an upgrade, trial resources stop and can later be deleted. Some capabilities are also restricted during the trial, including adding GPUs to virtual machines and creating Windows Server virtual machines.

The Free Tier is a set of recurring allowances

The Free Tier provides no-cost use of selected services up to documented limits. It has no fixed end date, but Google can change or remove allowances with advance notice. Limits are normally calculated per billing account, and unused allowance does not roll over.

A billing account is still required. “Free Tier” does not mean “no billing setup.” With a paid billing account, usage beyond a free limit is charged at standard rates. During the Free Trial, eligible overage draws from the remaining trial credit.
  

Program	Duration	Best use	What happens at the limit
Free Trial	90 days	Larger tests and proofs of concept	Usage consumes the $300 credit
Free Tier	No fixed end date	Small recurring workloads	Paid accounts incur overage
Product trial	Varies	Testing a specific managed service	Product-specific terms apply

The Free Tier is not an account-wide spending cap. Each participating service has its own eligible resource types, regions, and usage measurements.

Six options cover very different jobs

The largest quota is not always the best value. A service that scales to zero can be cheaper for intermittent traffic, while a small virtual machine is easier when you need operating-system control.

Option	Free allowance	Best for	Main caveat
Compute Engine	1 e2-micro VM-month	Small Linux server	Only 3 US regions
Cloud Run	2M requests + compute	Containers and APIs	Egress and add-ons
Cloud Run functions	2M invocations + compute	Events and webhooks	Build/image storage
App Engine Standard	Daily instance hours	Managed web apps	Standard only
GKE	Cluster fee credit	Kubernetes learning	Workers still cost
Cloud Shell	Shell + 5 GB disk	Admin and tutorials	Not production hosting

Fast recommendations

• Choose Compute Engine when you need Secure Shell (SSH), a full Linux environment, custom packages, or a process that stays online.
• Choose Cloud Run when your application is packaged as a container and traffic varies. It can scale down when no requests arrive.
• Choose Cloud Run functions for small event handlers, scheduled automation, file-processing triggers, and webhooks.
• Choose App Engine Standard when you want a managed application platform and your runtime fits its supported environment.
• Choose GKE only when Kubernetes itself is part of the requirement. The free credit covers cluster management, not the entire workload.
• Choose Cloud Shell to learn, run the Google Cloud CLI, edit code, and manage resources without configuring a local workstation.

Best default for a small modern web app: Cloud Run. Its request-based model, container portability, and ability to scale down make it a strong starting point for low or irregular traffic. Choose a VM instead when persistent processes or operating-system access matter more.

Compute Engine is the closest thing to a free server

The Compute Engine allowance provides a small general-purpose virtual machine (VM). It is the most familiar choice for users who want root access and control over the operating system.

non-preemptible e2-micro VM instance per month

What the allowance includes

• Eligible machine: e2-micro.
• Eligible regions: us-west1 (Oregon), us-central1 (Iowa), or us-east1 (South Carolina).
• Storage: 30 GB-months of standard persistent disk.
• Outbound transfer: 1 GB per month from North America to destinations other than China and Australia.

The VM limit is measured by eligible running time, not by a specific instance name. Google combines e2-micro usage across the supported regions until the account has consumed the number of hours in that month. One instance can therefore run for the whole month, or multiple eligible instances can share the same hour allowance.

Where a free VM works well

An e2-micro can handle lightweight tasks: a low-traffic personal site, a small reverse proxy, a development service, a monitoring agent, or a basic automation host. It is also useful for learning Linux administration because it behaves like a conventional server.

Where it becomes a poor fit

The machine is intentionally small. Memory-heavy content management systems, busy databases, build pipelines, video processing, and sustained CPU work can overwhelm it. A free VM also requires patching, firewall management, backups, and service monitoring. If your website receives occasional traffic and can run in a container, Cloud Run may use the free allowance more efficiently.

Keep every component eligible. A different region, a larger disk, snapshots, extra outbound traffic, a paid operating-system image, or another attached service can create charges. GPUs and Tensor Processing Units (TPUs) are explicitly excluded from the Compute Engine Free Tier.

Cloud Run makes intermittent traffic economical

Cloud Run executes containerized services without requiring you to manage servers. With request-based billing, the recurring allowance includes 2 million requests, 180,000 vCPU-seconds, and 360,000 GiB-seconds of memory per month. It also includes 1 GB of outbound data transfer from North America per month.

Those limits are independent: staying below two million requests does not guarantee a zero bill if CPU time, memory time, or network transfer exceeds its own allowance. Free usage is aggregated across projects linked to the billing account and resets monthly.

Request-based or instance-based billing?

Request-based billing is usually the natural fit for HTTP services that sit idle between requests. Instance-based billing can make sense for steady work or background activity; its free allowance is 240,000 vCPU-seconds and 450,000 GiB-seconds per month. Google applies the free tier as a spending-based discount using Tier 1 pricing, so region selection still matters.

Strong Cloud Run use cases

• Low-traffic websites and APIs
• Containerized microservices
• Preview environments
• Webhook receivers
• Short batch-style jobs

Watch closely

• Minimum instances
• Long-running requests
• High memory allocation
• Internet data transfer
• VPC connectors and load balancing

Cloud Run functions removes container management

Cloud Run functions is designed for code that runs in response to an HTTP request or event. The published 1st generation free tier includes 2 million invocations, 400,000 GB-seconds, 200,000 GHz-seconds, and 5 GB of outbound data transfer per month.

Functions are ideal for focused tasks, but the deployment pipeline matters. Google notes that function images are stored in a container registry and that Cloud Build and Artifact Registry have separate pricing. Artifact Registry includes 0.5 GB of free storage per month; retained images or frequent builds can consume that allowance.

Other free compute options serve narrower needs

App Engine Standard: managed application hosting

App Engine Standard includes 28 F1 instance-hours and 9 B1 instance-hours per day, plus 1 GB of outbound data transfer per day. Automatic scaling can make the allowance practical for a small application because idle instances can shut down. The trade-off is a more opinionated runtime and deployment model than a general VM or portable container.

The free allowance applies to the standard environment only. App Engine Flexible runs on virtual machine resources and does not provide the same free tier.

Google Kubernetes Engine: the control plane may be free

Google Kubernetes Engine (GKE) provides $74.40 in monthly credits per billing account, equivalent to the cluster management fee for one Autopilot or zonal Standard cluster for a typical month. The credit does not cover worker compute, networking, or other resources. A cluster can therefore have a covered management fee while its workloads still generate charges.

GKE is a good learning choice when you specifically need Kubernetes objects, deployment patterns, or cluster operations. It is usually too complex for a single small website that could run on Cloud Run or a small VM.

Cloud Shell: free tools, not an application host

Cloud Shell is a browser-based, authenticated command environment with the Google Cloud CLI and common developer utilities pre-installed. It includes 5 GB of persistent disk storage and a built-in editor. Use it for tutorials, administration, quick tests, and deployments. Do not treat it as an always-on production server.

Cloud Build: free build capacity

Cloud Build is supporting compute rather than application hosting. Each billing account currently receives 2,500 free build-minutes per month on the e2-standard-2 machine type in the default pool. This can cover lightweight continuous integration and container builds, but network transfer and non-eligible configurations are separate.

Architecture tip: A small free-stack project might use Cloud Build to create an image, Artifact Registry to store it, and Cloud Run to serve it. Each component has its own allowance, so monitor them separately.

The right choice minimizes idle cost and operations

Start with the workload’s behavior, not the service name. The following questions narrow the decision quickly.

1. Do you need full operating-system access?
   Choose Compute Engine when you need SSH, background daemons, custom networking software, or packages that do not fit a managed runtime.
2. Can the application run in a container?
   Choose Cloud Run for portable web services, APIs, and applications with variable traffic. Let the service scale down instead of paying for an idle VM.
3. Does one event trigger one small task?
   Choose Cloud Run functions for webhooks, scheduled handlers, storage events, and compact integrations.
4. Do you want a managed web platform?
   Choose App Engine Standard when its runtime and deployment model fit your application and you prefer platform conventions over infrastructure control.
5. Is Kubernetes itself a requirement?
   Choose GKE for cluster-specific learning or multi-service orchestration. Do not choose it merely to host one small container.
6. Are you only learning or administering?
   Choose Cloud Shell for command-line access and experiments without maintaining a workstation or server.

Three practical example stacks

Project	Recommended compute	Reason
Personal API	Cloud Run	Bursty HTTP traffic; scale down
Linux learning lab	Compute Engine	Root access and persistent VM
Image upload trigger	Cloud Run functions	Event-driven execution
Managed Python app	App Engine Standard	Simple platform deployment
Kubernetes practice	GKE	Cluster concepts are the goal
CLI tutorial	Cloud Shell	No environment setup

For production systems, choose based on reliability, support, security, and expected growth as well as the free allowance. A design that is cheap at low traffic can become expensive or operationally awkward at scale.

Guardrails matter more than the word “free”

Google Cloud free compute can remain at no cost when every billable component stays inside its own allowance. The safest setup combines conservative resource choices, visibility, and cleanup.

1. Create a separate project. Isolate experiments so usage is easier to identify in billing reports.
2. Select an eligible region and resource type. For the free Compute Engine VM, that means e2-micro in us-west1, us-central1, or us-east1.
3. Start with minimum resources. Avoid minimum instances on serverless services unless low latency justifies continuous allocation.
4. Create billing budgets and alerts. Set several thresholds so you receive warnings before spending grows.
5. Review every dependent service. Storage, image registries, builds, logs, network transfer, load balancers, and databases are metered separately.
6. Delete unused resources. Stopping compute does not necessarily delete disks, snapshots, images, or reserved infrastructure.
7. Recheck limits before publishing. Google can change Free Tier allowances, and region-specific prices can differ.

Budgets are usually alerts, not hard caps. Google Cloud’s standard budgets notify you when actual or forecasted costs cross thresholds. They do not automatically stop all usage. Automated responses are possible, but they require deliberate configuration and can disrupt services.
  

Common reasons a “free” project produces a charge

• The resource was created in a non-eligible region or with a non-eligible machine type.
• Outbound internet traffic exceeded the service’s allowance.
• A disk, snapshot, container image, or log remained after compute was stopped.
• A serverless minimum instance kept resources allocated while idle.
• Usage was split across projects but aggregated under the same billing account.
• A dependent service had a separate, smaller, or nonexistent free allowance.

Treat free limits as a discount applied to measured usage, not as a sandbox that cannot charge. Check the Billing report after deployments and traffic tests.

Frequently asked questions

Is Google Cloud Compute Engine free forever?

The eligible e2-micro allowance has no fixed end date, but it is limited by machine type, region, disk, running time, and network transfer. Google can change the Free Tier. Usage outside the allowance is billable on a paid account.

Can I run a website for free on Google Cloud?

Yes, a small site may fit within Compute Engine, Cloud Run, or App Engine Standard allowances. Whether the total bill is zero depends on traffic, memory and CPU use, storage, build artifacts, logging, and outbound transfer.

Does Google Cloud require a credit card for free compute?

A valid billing account is required for the Free Tier. Free Trial signup also requires a valid payment method for verification. Google states that a Free Trial account is not billed unless it is upgraded.

Which Google Cloud free compute option is best?

Cloud Run is the strongest general choice for a small containerized web service with intermittent traffic. Compute Engine is better when you need a traditional server. Cloud Run functions is better for event-driven tasks.

Does the free allowance reset every month?

Monthly Free Tier limits reset, and unused allowance does not roll over. Some App Engine limits are measured daily. Always check the product’s pricing page because units and reset periods differ.

Official sources

1. Google Cloud Free Program: free features, trial terms, and usage limits
2. Cloud Run pricing and free tier
3. Cloud Run functions (1st gen) pricing
4. App Engine pricing
5. Google Kubernetes Engine pricing
6. Cloud Shell documentation
7. Cloud Build pricing
8. Cloud Billing budgets and alerts

Free-tier terms and quotas can change. Confirm the current limits on the official pages before deploying a workload that must remain at zero cost.