All writing

ArchitectureBy 8 min read

GKE or Cloud Run? Choosing where an enterprise MVP runs, and the go-live checklist

How to decide between serverless Cloud Run and GKE workloads on Google Cloud: traffic shape, cost model, operational burden, team skills and hard limits, with a decision flowchart, both deployment topologies, how the Cloud Deploy pipeline changes, and the checklist I use before go-live.

Series · Part 7 of 7Enterprise MVP, end to end
  1. Enterprise MVP, end to end: from the first workshop to production
  2. Requirements gathering for an enterprise MVP: what to ask, what to write down
  3. Architecture design for an enterprise MVP: C4 diagrams, a modular monolith and the seams that matter
  4. Database design for an enterprise MVP: from domain model to the first PostgreSQL migration
  5. Developing an enterprise MVP with Flask and React: structure, workflow and tests
  6. CI/CD for an enterprise MVP: GitHub to Cloud Build to Cloud Deploy
  7. GKE or Cloud Run? Choosing where an enterprise MVP runs, and the go-live checklist
On this page · 9 sections
  1. What are the options on Google Cloud?
  2. How do Cloud Run and GKE compare?
  3. How do you decide?
  4. What does the Cloud Run deployment look like?
  5. When should you choose GKE instead?
  6. Does the CI/CD pipeline change if you move to GKE?
  7. What’s on the go-live checklist?
  8. The series in one paragraph
  9. Questions

“Should we run this on Kubernetes?” comes up in almost every architecture review I’ve been part of. Often the honest answer is “not yet”. Sometimes it’s “yes, and here’s why”. Either way, the answer should come from the requirements, and what the team would like on its CV shouldn’t come into it.

This is the final part of a series following an illustrative supplier onboarding portal from requirements to production. The pipeline from part 6 deploys to Cloud Run. Here I explain that choice, when I would make the other one, and what it takes to go live.

What are the options on Google Cloud?

For a containerised application there are three realistic choices:

  • Cloud Run runs serverless containers. You give it an image; it runs instances in response to requests and scales them, including to zero. It offers services (HTTP), jobs (run-to-completion tasks) and worker pools (always-on background workers).
  • GKE Autopilot is managed Kubernetes where Google runs the nodes. You write Kubernetes manifests; you’re billed for what your pods request, not for nodes.
  • GKE Standard is managed Kubernetes where you choose and pay for the node pools. It gives you the most control and the most responsibility.

All three run the same container image, so whatever you pick now can be changed later. For me, that counts for more than anything else in this decision.

How do Cloud Run and GKE compare?

CriterionCloud RunGKE (Autopilot / Standard)
Unit you manageA service, job or worker poolA cluster, plus deployments, services, ingress, autoscalers
ScalingPer request, automatic, can scale to zeroHorizontal Pod Autoscaler; cluster or node autoscaling; rarely to zero
Billing modelPer request (CPU billed only during requests) or per instanceAutopilot: per pod resource request. Standard: per node. Both pay a cluster management fee of $0.10/hour
ProtocolsHTTP/1.1, HTTP/2, gRPC, WebSocketsAnything, including raw TCP and UDP
Limits per instanceUp to 8 vCPU and 32 GiB; requests up to 60 minutes; up to 1,000 concurrent requestsWhatever the node type offers
Background workJobs (tasks up to 7 days), worker pools, Cloud TasksDeployments, Jobs, CronJobs, any long-running process
StateStateless; state lives in managed servicesStatefulSets and persistent volumes if you need them
ExtensibilitySidecars, GPUs (NVIDIA L4), Direct VPC egressOperators, DaemonSets, service mesh, custom schedulers, the whole Kubernetes ecosystem
Operational burdenVery low: no nodes, no upgrades, no cluster securityAutopilot: moderate. Standard: high. Upgrades, policies, add-ons, capacity
Skills neededContainers and Cloud Run configurationKubernetes, which takes real experience to operate well

How do you decide?

I take the requirements through a short set of questions, and the first “yes” usually settles it.

Choosing between Cloud Run and GKEChoose GKE for non-HTTP, stateful or DaemonSet workloads, an existing GKE platform team, or needs beyond Cloud Run limits. For steady high load model both costs. Otherwise choose Cloud Run.

yes

no

yes

no

yes

no

yes

no

Non-HTTP, statefulor DaemonSets?

GKE

Existing GKEplatform team?

GKE on theexisting platform

Steady highload 24×7?

Model both costs;GKE often cheaper

Beyond CloudRun limits?

Cloud Run

Applied to this project, using the numbers captured in part 2:

  • Traffic is ~50 internal users in business hours, ~500 suppliers a year, with quarter-end peaks. That traffic is spiky and mostly idle, which is exactly the pattern Cloud Run bills best.
  • The workload is a stateless HTTP API and a static frontend in one image. Background work (ERP sync, migrations) fits Cloud Tasks and Cloud Run jobs.
  • The availability target is 99.5% in business hours, regional. Cloud Run is regional by default, with no node failures to plan around.
  • The client’s IT operations team will own the system and has no Kubernetes experience. Handing them a cluster would mean handing them a new discipline.

Every answer points to Cloud Run, which is what ADR-004 in part 3 recorded.

What does the Cloud Run deployment look like?

Cloud Run deployment topologyUsers reach a global Application Load Balancer with Cloud Armor, Cloud CDN and managed TLS, which routes through a serverless NEG to a Cloud Run service using Cloud SQL, Cloud Storage and Secret Manager, with a migration job and Cloud Tasks.

Users

Global external Application Load BalancerCloud Armor · Cloud CDN · managed TLS

Serverless NEG

Cloud Run servicemin 1 · max 10 instances

Cloud SQL PostgreSQLHA · PITR backups

Cloud Storage

Secret Manager

Cloud Run job · db-migrate

Cloud Tasks

These are the settings that matter in production:

  • Minimum instances of 1 in production removes cold starts for the first user of the morning. It costs one idle instance; dev and staging scale to zero.
  • Concurrency of 40 with 1 vCPU suits a Flask app on Gunicorn threads, which spends most of its time waiting on PostgreSQL. Load testing decides the real number.
  • Ingress is restricted to the load balancer, so the only way in is through Cloud Armor and the CDN.
  • The service uses request-based billing, so CPU is billed only while handling requests. Instance-based billing is the better choice if the service does background work between requests.

When should you choose GKE instead?

Choose it when the workload needs something Cloud Run deliberately doesn’t do. These are the cases I see in practice:

  • Non-HTTP or long-lived connections at scale, such as MQTT brokers, game servers, or custom TCP or UDP protocols.
  • Stateful components you have to run yourself, such as a search cluster, a message broker or a vector database that has no suitable managed service and needs persistent volumes and stable identities.
  • Kubernetes-native tooling: operators, DaemonSets for node-level agents, service mesh policies across dozens of services, custom schedulers, or batch systems built on Kubernetes primitives.
  • Many services with steady, high utilisation. When dozens of services run busy around the clock, bin-packing them onto nodes (with committed-use discounts) is often cheaper than per-request pricing. Model it with real numbers before you assume it.
  • An existing platform. If the client already runs a well-operated GKE platform with security policies, observability and an on-call team, deploying onto it is usually the right call, even for a small app, because the operational cost is already paid.

If GKE is the answer, I start with Autopilot unless there’s a specific need for node-level control. It removes node management and bills by pod requests, which takes away most of what makes Kubernetes expensive for small teams.

For comparison, here is the same application on GKE:

GKE deployment topologyUsers reach an Application Load Balancer through the GKE Gateway API, which routes to an autoscaled app deployment. An ERP sync worker, an outbox dispatcher CronJob and a migration Job also use Cloud SQL.

Users

Application Load Balancervia GKE Gateway API

Deployment · appHPA 2–10 pods

Cloud SQL PostgreSQL

Cloud Storage

Deployment · erp-sync worker

CronJob · outbox dispatcher

Job · db-migrate (predeploy hook)

On a diagram it looks only slightly more complex. The extra work sits in what the diagram doesn’t show: cluster upgrades, network policies, Workload Identity bindings, pod security standards, resource requests that have to be tuned, and someone on call who understands all of it.

Does the CI/CD pipeline change if you move to GKE?

Very little, and that is why it’s safe to make the runtime decision early. Cloud Deploy supports both target types:

  • Add a target with gke: { cluster: projects/…/locations/asia-south1/clusters/portal } instead of run: { location: … }.
  • Add a Skaffold profile that renders Kubernetes manifests (a Deployment, a Service, an HTTPRoute) with deploy: kubectl: {} instead of cloudrun: {}.
  • The predeploy migration hook can stay as it is, or run as a Kubernetes Job on the cluster.

The image, the Cloud Build configuration, the approval gates and the rollback command stay the same. Moving runtimes then becomes a planned change to one stage, small enough that it never grows into a re-platforming project.

What’s on the go-live checklist?

Once the runtime is chosen and the pipeline works, I walk through this list with the client’s IT operations and security teams in the final two weeks. Nothing goes live until every line has an owner and a tick:

Security

  • Pen test completed; high and critical findings fixed and retested
  • Cloud Armor policy on the load balancer (OWASP rules, rate limiting on login and magic-link endpoints)
  • No service-account keys exist; IAM reviewed against least privilege
  • Secrets only in Secret Manager; rotation procedure written

Data

  • Cloud SQL high availability on, automated backups and point-in-time recovery enabled
  • A restore actually tested into a scratch instance, with the time measured against the 4-hour RTO
  • Spreadsheet data migrated, reconciled with the business, and signed off

Reliability

  • Load test at 3× the expected quarter-end peak, with p95 latency within target
  • Uptime checks and alerting on error rate, latency, Cloud Tasks backlog and outbox age
  • Dashboards for the service, database and queues, and structured logs with request IDs
  • Rollback rehearsed in staging with gcloud deploy targets rollback

Operations

  • Runbook: deploy, roll back, re-drive failed ERP syncs, restore from backup, rotate a secret
  • On-call rota and escalation path agreed for the first month
  • Hyper-care plan: daily check-in with the business for the first two weeks
  • Hand-over sessions with the client’s team, using the ADRs and data dictionary

Business

  • User acceptance testing signed off against the acceptance criteria from part 2
  • Training done for procurement, compliance and finance; supplier help page live
  • Success measure baseline recorded (current median onboarding time) so the improvement can be proven

The restore test is the line teams most often want to skip, and I never let them. Until you’ve restored a backup, you don’t know it works.

The series in one paragraph

Requirements written as numbers decided the architecture. The architecture’s seams decided the schema and the code structure. Expand-then-contract migrations made the pipeline safe to run on every merge, and the pipeline made the runtime choice reversible. Each phase left an artefact behind (scope, ADRs, ERD, contract, pipeline, checklist), so the system can be understood and owned by people who weren’t in the room. That is what I want from an enterprise MVP: small, and built so that someone else can own it.

If you’re starting from the beginning, part 1 has the map. If you’re weighing a cloud migration rather than a new build, migrating legacy systems to Google Cloud and cutting the bill by 40% covers the other side of the same decisions.

Choose the runtime your requirements need and your team can operate, and keep the option of moving to the other one.

Questions

Should an enterprise MVP run on Cloud Run or GKE?

Cloud Run, if the MVP is a stateless HTTP service with spiky or low traffic. It scales to zero, bills for what you use, and leaves no cluster to patch or upgrade. Choose GKE when the workload needs non-HTTP protocols, stateful pods, DaemonSets or operators, or when a platform team already runs Kubernetes.

Is GKE cheaper than Cloud Run?

Only at steady, high utilisation. Cloud Run charges per request or per instance, GKE Autopilot per pod resource request and GKE Standard per node, and both GKE modes add a $0.10 per hour cluster fee. GKE’s free tier gives each billing account $74.40 a month in credit, enough to cover that fee for one Autopilot or zonal cluster; it doesn’t apply to regional clusters or to compute. When dozens of services are busy around the clock, packing them onto nodes with committed-use discounts often costs less, so model both with real numbers.

What are Cloud Run’s limits?

Each instance can have up to 8 vCPU and 32 GiB of memory, handle requests of up to 60 minutes and serve up to 1,000 concurrent requests. Cloud Run speaks HTTP/1.1, HTTP/2, gRPC and WebSockets, but not raw TCP or UDP. Jobs can run tasks for up to 7 days.

Can you move from Cloud Run to GKE later?

Yes. Both run the same container image and Cloud Deploy supports both target types, so the move takes a new GKE target and a Skaffold profile that renders Kubernetes manifests. The image, the Cloud Build configuration, the approval gates and the rollback command stay the same.

GKE Autopilot or GKE Standard?

Start with Autopilot unless you need control at the node level. Google runs the nodes and bills by pod requests, which removes most of what makes Kubernetes expensive for a small team.