System Atlas
the atlas
DB · Databases7 minApplied

Which database should I use on AWS

Seven managed engines, one rule — match the database to the shape of your data and access pattern.

the gist

AWS offers a purpose-built database for each workload: RDS/Aurora for relational data with joins and transactions, DynamoDB for serverless key-value/document access at any scale, ElastiCache for microsecond in-memory caching, Redshift for analytical warehousing, DocumentDB for MongoDB-compatible documents, Neptune for graph relationships, and Timestream for time-series metrics. Pick by how you read and write, not by habit.

ANALOGY // It's like picking the right vehicle: a sedan (RDS) for everyday structured trips, a fleet of identical delivery vans that scale infinitely (DynamoDB), a motorbike for speed (ElastiCache cache), a freight train for bulk analytics (Redshift), and specialized rigs for special cargo — documents, maps of connections, or a continuous stream of timestamps.
living diagram01 / 07
RDS / Aurorarelational · SQL · ACID
DynamoDBkey-value · serverless
ElastiCachein-memory cache
Redshiftcolumnar warehouse · OLAP
DocumentDBMongoDB-compatible docs
Neptunegraph · relationships
Timestreamtime-series · metrics
No single winner — each engine is purpose-built for a workload shape.
01

Start from the workload

There is no single 'best' AWS database — the right answer is dictated by how your data is shaped and how you access it. The first questions are: is the data relational, key-value, document, graph, or time-series? Are you doing many small transactions or scanning huge volumes for analytics? Do you need strong consistency and joins, or raw scale and simplicity? Every choice below falls out of those answers.

02

RDS / Aurora — relational

Reach for RDS (managed PostgreSQL, MySQL, and others) or Aurora when your data has clear relationships and you need SQL joins plus ACID transactions — the default for most business applications. Aurora is AWS's cloud-native reimplementation with a distributed storage layer, giving better performance and availability while staying MySQL/Postgres-compatible. Choose this whenever correctness and structured querying matter more than infinite scale.

03

DynamoDB — serverless key-value

DynamoDB is a fully managed, serverless key-value and document store that delivers single-digit-millisecond reads at effectively unlimited scale with zero servers to provision. It shines for high-throughput access by a known key — user sessions, shopping carts, IoT state — where you never need ad-hoc joins. The trade is that you must model your tables around your access patterns up front, because flexible relational queries aren't its game.

04

ElastiCache — the cache

ElastiCache is managed Redis or Memcached: an in-memory layer that answers hot reads in microseconds, sitting in front of a slower system of record. Use it to absorb repeated reads, hold sessions, rank leaderboards, or rate-limit — not as your durable source of truth. It's the AWS answer whenever the bottleneck is read latency on data you fetch over and over.

05

Redshift — the warehouse

Redshift is a columnar, massively-parallel data warehouse built for OLAP: analytical queries that scan and aggregate billions of rows for dashboards and reporting. Its column storage and distribution make big aggregations fast, but it's the wrong tool for high-frequency single-row writes. Reach for it when the question is 'analyze all our historical data,' not 'serve one user's request.'

06

DocumentDB — Mongo-compatible

DocumentDB is a managed, MongoDB-compatible database for document workloads where records are flexible, nested JSON-like objects rather than fixed rows. It fits content management, catalogs, and user profiles whose shape varies from record to record. Choose it when you want MongoDB's document model and API without operating MongoDB yourself.

07

Neptune & Timestream — specialized

The last two are for data whose *shape* is the point. Neptune is a graph database optimized for highly connected data — social networks, fraud rings, recommendation graphs — where the value is in traversing relationships, not rows. Timestream is purpose-built for time-series: metrics, IoT sensor readings, and events indexed by time, with built-in rollups and retention. Pick these only when a relational or key-value store would fight the data's natural structure.

the full picture
01

Why AWS has so many databases

A decade ago the answer to "which database?" was almost always "a relational one," and you bent every problem to fit tables and rows. AWS's catalog reflects a newer philosophy: purpose-built databases, one engine per major workload shape, because forcing a graph traversal or a firehose of sensor readings into a relational schema is possible but painful and slow. The skill AWS is really testing when this comes up in interviews is whether you can *match the tool to the data*, rather than reflexively reaching for the one you know.

The decision always starts from two questions, not from a product name:

  • What shape is the data? Structured rows with relationships, opaque values by key, flexible documents, a graph of connections, or a stream of time-stamped points?
  • How do you access it? Many small transactions, lookups by a known key, or huge analytical scans and aggregations? Read-heavy or write-heavy? Do you need joins and strong consistency, or raw scale and simplicity?

Answer those, and the right engine usually names itself. What follows is the map from workload to service.

02

The relational default: RDS and Aurora

For the majority of business applications, a relational database is still the correct default, and on AWS that means RDS or Aurora. Relational engines give you SQL, joins across tables, and ACID transactions — the guarantees that let you move money, book inventory, or update related records without corrupting your data. Whenever the data has clear relationships and correctness matters more than infinite scale, this is where you start.

RDS (Relational Database Service) is managed hosting for standard engines — PostgreSQL, MySQL, MariaDB, SQL Server, Oracle. AWS handles patching, backups, replication, and failover; you get the exact database you'd run yourself, minus the operational toil.

Aurora is AWS's cloud-native reimplementation of MySQL and PostgreSQL. It keeps wire compatibility with those engines but replaces the storage layer with a distributed, self-healing system replicated across availability zones, delivering several times the throughput, faster failover, and read replicas that share storage. The mental model: choose RDS when you want a familiar engine managed for you, and Aurora when you want that same SQL interface with better performance and availability and are willing to pay a premium. Either way, this tier is your answer for transactional, relational workloads.

03

Scale and speed: DynamoDB and ElastiCache

When the relational model's guarantees aren't what you need — and its scaling limits are — two non-relational engines take over.

DynamoDB is a fully managed, serverless key-value and document database. There are no instances to size; it scales seamlessly from a handful of requests to millions per second while holding single-digit-millisecond latency, and you pay per request or provisioned capacity. It excels at access by a known key at enormous scale: user profiles, session state, shopping carts, IoT device state, gaming leaderboards. The price of that scale is a different way of thinking — you model tables around your access patterns up front rather than normalizing and joining later, because DynamoDB deliberately doesn't offer the flexible ad-hoc joins a relational engine does. If you find yourself wanting complex joins, DynamoDB is the wrong choice.

ElastiCache is managed Redis or Memcached — an in-memory cache, not a system of record. It sits in front of a slower database and answers hot, repeated reads in microseconds, and it's also the natural home for sessions, rate limiters, leaderboards, and pub/sub. The distinction to keep clear: DynamoDB is durable primary storage that happens to be fast; ElastiCache is a volatile speed layer you place *in front of* your durable store. Reach for it when read latency on frequently accessed data is the bottleneck.

04

Analytics and the specialized engines

The remaining services each own a data shape that would fight a general-purpose store.

Redshift is a columnar, massively-parallel data warehouse for OLAP — online analytical processing. Where RDS and DynamoDB serve one user's request quickly (OLTP), Redshift is built to scan and aggregate *billions* of rows for dashboards, business intelligence, and reporting. Storing data by column instead of by row makes big aggregations (SUM, AVG, GROUP BY over huge ranges) dramatically faster, but it's the wrong tool for high-frequency single-row inserts and updates. Use it to answer "analyze all our history," never to serve live transactions.

DocumentDB is a managed, MongoDB-compatible document database. When records are flexible, nested JSON-like objects whose shape varies — content, catalogs, user profiles with optional fields — the document model fits better than rigid rows, and DocumentDB gives you MongoDB's API without operating MongoDB yourself.

Neptune is a graph database for highly connected data — social graphs, fraud rings, recommendation and knowledge graphs — where the value lives in *traversing relationships* (friends-of-friends, shortest paths) that would require ruinous recursive joins in SQL.

Timestream is purpose-built for time-series: metrics, IoT sensor readings, and events indexed primarily by time, with native rollups, retention tiers, and time-window functions that a relational table handles clumsily.

05

A practical decision framework

Put together, the choice collapses into a short flowchart you can run in your head:

  • Relational data with joins and transactions? → RDS, or Aurora if you want cloud-native performance. This is the default; only leave it for a concrete reason.
  • Simple lookups by key at massive, unpredictable scale, and you want serverless? → DynamoDB.
  • The bottleneck is read latency on hot data? → ElastiCache in front of your primary store.
  • Heavy analytical scans and aggregations over huge volumes? → Redshift.
  • Flexible, nested documents? → DocumentDB. Connected/graph data? → Neptune. Time-stamped metrics? → Timestream.

Two caveats keep this from being dogma. First, real systems combine these — a typical architecture might use Aurora as the system of record, DynamoDB for high-scale session data, ElastiCache as a cache, and Redshift for analytics fed by a nightly pipeline. Picking a database is rarely a single choice; it's assigning each workload to the engine that fits it. Second, avoid over-engineering: if a single well-indexed Postgres on RDS comfortably handles your load, you don't need six specialized services. Match the tool to the workload, add engines only as distinct workloads emerge, and you'll get both performance and a system you can actually operate.

what to remember
01

RDS / Aurora — managed relational (Postgres, MySQL): use when you need SQL joins, ACID transactions, and structured relationships. Aurora is the cloud-native, higher-performance option.

02

DynamoDB — serverless key-value/document store: single-digit-millisecond reads at any scale, no servers to manage; design around access patterns, not joins.

03

ElastiCache — managed Redis/Memcached: an in-memory cache for microsecond reads of hot data, not a system of record.

04

Redshift — columnar data warehouse: for OLAP analytics scanning huge volumes, not for high-frequency transactional writes.

05

DocumentDB (MongoDB-compatible), Neptune (graph), Timestream (time-series) — specialized engines for document, relationship, and time-stamped workloads.

06

The decision rule: relational + transactions → RDS/Aurora; massive key lookups → DynamoDB; cache → ElastiCache; analytics → Redshift; else match the specialized engine to the data shape.

check yourself

Quick quiz

Q1

You need a serverless store for shopping-cart state, accessed by user ID at massive scale with no ad-hoc joins. Which AWS service fits best?

Q2

Your team needs to run large analytical aggregations over billions of historical rows for dashboards. Which engine is purpose-built for that?

follow the thread