Skip to main content
Cloud-Native Databases: Choosing the Right Database for Your Workload

Cloud-Native Databases: Choosing the Right Database for Your Workload

KU
· Founder & Chief Editor
• 8 min read•Updated •

Postgres, DynamoDB, Redis, Elasticsearch, Snowflake. Each fits a different workload. The decision criteria, not the marketing comparison.

Key takeaways

  • A cloud-native database scales out or autoscales, replicates across zones, fails over without a human, and runs as a managed service or Kubernetes operator.
  • Default to managed Postgres, add DynamoDB for high-throughput key-value access, and add Redis, search, or a warehouse only when a specific workload demands it.

A cloud-native database is one designed for cloud or Kubernetes infrastructure: it scales horizontally or automatically, replicates across availability zones, fails over without a human, and is run as a managed service or operator. Our verdict: default to managed Postgres, and add other engines only for access patterns Postgres cannot serve.

Verified against

PostgreSQL 18, CloudNativePG 1.30, Vitess 24, against the PostgreSQL release notes, the CloudNativePG docs, and the Amazon DynamoDB developer guide. Checked October 2026.

What makes a database cloud-native

The CNCF defines cloud native as building and running workloads "at scale in a programmatic and repeatable manner" on public, private, or hybrid cloud. For a database that translates into four properties:

  • Elastic scale: capacity grows by adding nodes or by provider autoscaling, not by buying a bigger box.
  • Built-in replication and failover: copies live in more than one zone and a primary loss is handled automatically.
  • Declarative operation: clusters, backups, and upgrades are API calls or Kubernetes resources, not runbooks.
  • Usage-shaped cost: you pay for what runs, and some options scale to zero.

Examples span both models: managed services like Aurora, DynamoDB, and Snowflake, and open-source projects like Vitess (sharded MySQL, a CNCF Graduated project, at v24 as of October 2026) and CloudNativePG (a Kubernetes operator for highly available Postgres). This post covers five engines: Postgres (for example on RDS), DynamoDB, Redis (for example on ElastiCache), OpenSearch, and Snowflake, and a decision tree for when a new service asks "what should I store this in?"

The default: Postgres

Most workloads start in Postgres unless there is a specific reason otherwise. The relational model is understood by nearly every developer; transactions, foreign keys, and joins work as expected; backups, failover, and monitoring are mature; pgvector adds vector search and JSONB handles semi-structured data.

On Kubernetes, "declarative operation" looks like this. A three-instance CloudNativePG cluster gives you one primary, two replicas, and automated failover:

k8s/orders-db.yaml
apiVersion: postgresql.cnpg.io/v1
kind: Cluster
metadata:
  name: orders-db
spec:
  instances: 3
  storage:
    size: 50Gi
Terminal
kubectl apply -f k8s/orders-db.yaml
kubectl get cluster orders-db

Postgres stops being the answer when the access pattern is a single-key lookup at very high throughput (DynamoDB), the data is hot and ephemeral (Redis), the query is full-text search (OpenSearch), or the work is large read-only aggregation (Snowflake or BigQuery). If your read load is the problem rather than the data model, routing reads to Postgres replicas usually buys years before any migration.

DynamoDB: key-value at scale

DynamoDB is right for very high write throughput, predictable single-key lookups, single-digit-millisecond latency, and workloads that must scale out without a migration. Typical uses are session state, idempotency keys, event streams with TTL expiry, and feature-flag state. A session table with on-demand billing and TTL is two commands:

Terminal
aws dynamodb create-table --table-name sessions \
    --attribute-definitions AttributeName=pk,AttributeType=S \
    --key-schema AttributeName=pk,KeyType=HASH \
    --billing-mode PAY_PER_REQUEST
aws dynamodb update-time-to-live --table-name sessions \
    --time-to-live-specification "Enabled=true,AttributeName=expires_at"

It is bad at joins, aggregations, and range queries on non-key fields. It performs by your access pattern, so a new query shape means a redesign. Reads are eventually consistent by default; strongly consistent reads are opt-in per request. Done well, with single-table design, GSIs for alternate access patterns, and sort keys that encode hierarchy, it scales beautifully. Treated like a relational database, it gets expensive and slow.

Redis, OpenSearch, and Snowflake: the specialists

Redis is right for caching, sorted-set leaderboards, counters, token-bucket rate limiting, lightweight pub/sub, and distributed locks with caveats. It is fast partly because durability is optional, so it is wrong for data you cannot lose, and RAM makes large datasets expensive. Do not use Redis as a primary store; keep a source of truth in Postgres or DynamoDB that can rebuild the cache.

OpenSearch (or Elasticsearch) handles full-text search, faceted filtering, and log aggregations. It is eventually consistent, has no transactions, and is heavy to operate, which is the main argument for a managed service such as Amazon OpenSearch Service over self-managed clusters.

Snowflake is the OLAP side of the OLTP/OLAP split: product analytics, financial reporting, cohort analysis, and joins across replicated Postgres, Salesforce, and Stripe data. Sub-second operational queries and per-record CRUD are not what it is for.

EngineData modelConsistencyScales writes byOps loadRestore story
Postgres (RDS, CloudNativePG)RelationalStrongBigger primaryLow (managed)Point-in-time recovery
DynamoDBKey-valueEventual by defaultPartitions, automaticVery lowPITR
Redis (ElastiCache)In-memory structuresOptional durabilityCluster shardsLowRebuild from source
OpenSearchDocuments, inverted indexEventualShardsMediumSnapshot restore
SnowflakeColumnar warehouseStrong, batchWarehouse sizeVery lowTime Travel

The decision tree

  1. Transactional, relational, under a few TB? Postgres.
  2. Key-value, very high throughput? DynamoDB.
  3. Ephemeral hot data with a backing source? Redis.
  4. Full-text search over documents? OpenSearch or Elasticsearch.
  5. Analytics over large data? Snowflake.
  6. Vectors for ML retrieval? pgvector if you are on Postgres, a dedicated store only past where that stops scaling; see choosing a vector database.
  7. High-volume time series? ClickHouse or Timescale.

Most workloads end at step 1 or 2.

Failure modes and the errors they print

  • FATAL: sorry, too many clients already (Postgres). Every service opened its own pool against one primary. Put PgBouncer or RDS Proxy in front and cap pool sizes; raising max_connections just moves the memory problem.
  • ProvisionedThroughputExceededException (DynamoDB). A hot partition key, or provisioned capacity too low for a burst. Spread writes across more key values, or switch the table to on-demand.
  • OOM command not allowed when used memory > 'maxmemory' (Redis). The cache filled with no eviction policy. Set maxmemory-policy allkeys-lru for pure caches and put TTLs on keys.
  • Snowflake behind a user-facing dashboard. No error, just multi-second queries. Precompute aggregates into Postgres or DynamoDB and serve those.
  • DynamoDB as a relational database. Six GSIs later, costs climb and consistency gets weird. Postgres was the right answer.

Where this advice breaks

The "default to Postgres" rule assumes one region and a write load one primary can absorb. Multi-region active-active writes push you toward DynamoDB global tables, CockroachDB, or Spanner, and the data-model tradeoffs differ. Strict data-residency rules can rule out a managed service entirely. And at very small scale, a single managed Postgres plus nothing else beats any of this; we cover that edge in serverless vs traditional databases.

Questions people ask

What is a cloud-native database?

It is a database built for elastic, failure-prone cloud infrastructure rather than a single server. It scales out or autoscales, keeps replicas in several availability zones, fails over automatically, and is operated through APIs or Kubernetes resources. Aurora, DynamoDB, CockroachDB, and Snowflake are managed examples; Vitess and CloudNativePG bring the same properties to MySQL and Postgres on your own Kubernetes clusters.

Is Postgres a cloud-native database?

Postgres itself is a single-primary server, but run as a managed service like RDS Multi-AZ or Aurora, or through a Kubernetes operator like CloudNativePG, it gets the cloud-native properties: automated failover, declarative backups, and replicas across zones. What it does not get is write scale-out. When one primary is the bottleneck, look at DynamoDB, Vitess, or CockroachDB.

Which cloud-native database should a new team start with?

Managed Postgres plus Redis for caching covers most products. Add DynamoDB when a clear, stable key-value access pattern outgrows Postgres, search when users need full-text queries, and a warehouse when analytics slow down production. For spiky traffic, scale-to-zero options remove idle cost; we compared them in best serverless databases.

The call we'd make

Default to managed Postgres; it fits most workloads and the operations are mature. Use DynamoDB when the access pattern is clear and stable, Redis only with a source of truth, and search engines and warehouses only for search and analytics. Most teams do not need five databases. Add an engine only when a workload has a genuinely different shape, because every later migration between engines is expensive.

Sources

Explore topics:Cloud
React
Share this post
Cite this article
Plain text

Kiril Urbonas (2025). Cloud-Native Databases: Choosing the Right Database for Your Workload. DevOpsNess. Updated 2026-10-31. https://www.devopsness.com/blog/cloud-native-databases-choosing-right-database-workload

Markdown

[Cloud-Native Databases: Choosing the Right Database for Your Workload](https://www.devopsness.com/blog/cloud-native-databases-choosing-right-database-workload) (Kiril Urbonas, DevOpsNess, updated 2026-10-31)

KU

Kiril Urbonas

Founder & Chief Editor

608 articles
View all articles by Kiril Urbonas

You might have missed

Evergreen posts worth revisiting.