
Provider comparisons usually operate at the wrong altitude. Whether AWS or Google Cloud has more services is not a decision input; both have more than you will use. The differences that shape your next two years are lower down, in the compute abstractions you build on — because those determine how much operations work you keep, and how much of your system can move if you ever need it to.
Two comparisons carry most of the weight.
Managed Kubernetes: how much is left with you
Both GKE and EKS give you a managed control plane. The difference is what remains your responsibility below it.
GKE, particularly in its fully managed node mode, removes node management almost entirely — sizing, provisioning, upgrade sequencing, and most of the add-on version compatibility work disappear. EKS leaves more of that with you: node groups you define, add-on versions you track, upgrade ordering you plan.
Neither is objectively better. The question is what that difference costs at your team size.
For four engineers with no platform specialist, the gap is roughly a part-time role — someone spends a day or two a month on cluster maintenance instead of product work, plus the occasional bad week when an upgrade goes sideways. For forty engineers with a dedicated platform group, the same gap is a preference, and the additional control EKS gives you may genuinely be worth having.
Most Kubernetes advice online is written by and for the second group and read by the first. That mismatch produces a lot of over-engineered clusters.
The prior question: should you be running Kubernetes at all right now? It solves coordination problems that emerge with many services and many engineers. Before those problems exist, it costs velocity and buys optionality you are not using. A pre-product-market-fit team running nine services on a cluster has usually optimised for a future that has not arrived and is paying for it in the present. Two managed container services and a managed database carry most products a surprisingly long way.
Serverless: function-shaped vs container-shaped
Lambda and Cloud Run both scale to zero. They are not the same bet, and the difference propagates into your codebase.
Lambda is function-shaped. It rewards small, event-triggered units and penalises long-running processes and heavy dependency trees through cold-start latency. Its integration depth with the rest of AWS is genuinely excellent — if your architecture is event-driven across many AWS services, the plumbing is already there and fighting it costs more than it saves.
Cloud Run is container-shaped. You deploy the same artefact you run locally, which collapses the gap between development and production and eliminates a whole category of packaging weirdness. Concurrency per instance is configurable, which changes the cost profile for I/O-bound services considerably.
The portability difference is the part worth deciding on deliberately. A Cloud Run service is a container; containers run anywhere. A Lambda-native architecture with a dozen functions wired together through provider-specific event plumbing is substantially harder to relocate — the code is portable but the topology is not.
At early stage, when you have the least information and the most likely need to change your mind, the container-shaped abstraction preserves more optionality for roughly equivalent effort.
Databases: the choice that outlives the provider choice

Worth more deliberation than either of the above, and harder to reverse.
-
Managed PostgreSQL on either platform is the right default for most products, and at small scale the differences between providers are close to noise.
-
Aurora earns its premium when you have read-scaling requirements or need failover behaviour you can reason about under load. Not before.
-
DynamoDB is excellent with known, stable access patterns and punishing without them. Early-stage products change access patterns constantly — which is precisely the wrong condition for it.
-
Spanner solves horizontal scale with strong consistency, a real problem that most startups do not have and should not pay for until they do.
-
BigQuery is the strongest single argument for Google Cloud for anything analytics-heavy, and it can carry the decision alone.
The recurring failure: choosing an exotic database for a projected scale problem rather than an experienced one, then spending a year working around its constraints while the actual bottleneck sits untouched in the application layer.
How to weight all of this
The compute abstraction determines how much operational work you keep. The database determines where your data gravity accumulates. The data gravity determines how long your provider decision stays reversible.
That chain suggests a clean ordering: decide the database and data architecture first, let it inform the provider, and treat the compute abstraction as the layer where you optimise for portability because it is cheap to do so there.
Full guide with the workload characterisation framework, credit economics, AI inference analysis and migration cost breakdown: AWS vs Google Cloud for Startups. We also review architecture decisions if you want an external read.
Frequently Asked Questions
Is GKE genuinely easier to operate than EKS?
For small teams, yes — chiefly because its fully managed node mode removes node sizing, provisioning and upgrade sequencing. For teams with a dedicated platform group, the difference narrows and EKS's additional control can be worth having. Team size, not technology, decides which framing applies to you.
When should a startup adopt Kubernetes?
When service count and team size make coordination genuinely painful — not in anticipation of that. Before then it costs velocity and buys optionality you are not exercising. Two managed container services and a managed database will carry most products through product-market fit.
Does Cloud Run really preserve more portability than Lambda?
Yes, because the deployment unit is a container. Application code is portable in both cases, but a Lambda architecture's topology — functions wired through provider-specific event plumbing — is not. If your system is already event-driven across many AWS services, though, that integration depth outweighs the portability argument.
Should I default to managed PostgreSQL?
For most products, yes. It is well understood, well tooled, and adequate far beyond the scale most teams reach. Move away from it when you have a measured constraint it cannot meet, not when you have a projected one.
Is DynamoDB a bad choice for startups?
Not bad — situational. It performs excellently when access patterns are known and stable, and poorly when they change, because the data model is designed around the queries. Early-stage products change queries constantly, which makes it a poor fit at exactly the stage teams most often reach for it.
What decides the provider if everything else is close?
Where your largest dataset will live in two years, because that determines how long the choice stays reversible. If that is genuinely neutral too, pick the platform your team already knows and spend the saved deliberation on your product.