RDS Engines Compared

Amazon RDS (Relational Database Service — a managed service that runs a SQL database for you, handling patching, backups, and failover) does not have one database “brand.” Instead you pick an engine: MySQL, PostgreSQL, MariaDB, Oracle, Microsoft SQL Server, or Amazon Aurora. The engine you choose decides your licensing bill, which SQL features you get, how portable your data is, and how much you can scale. This page compares them in plain English and tells you what to pick for a new project.

The two families of engines

RDS engines split into two groups, and the difference matters more than any single feature.

Open-source engines — MySQL, PostgreSQL, and MariaDB. The database software is free. You only pay AWS for the compute (the server), storage, and backups. No separate software license.
Commercial engines — Oracle Database and Microsoft SQL Server. These are paid products. You either pay the license cost baked into the hourly price (“License Included”), or you bring your own license, called BYOL (Bring Your Own License). Either way you pay extra, and not every feature of the full product works on RDS.

Gotcha: A “commercial” engine is not just a different flavor of SQL — it is a long-term cost and lock-in decision. Oracle and SQL Server on RDS cost noticeably more per hour, and some native features are blocked because AWS manages the host (more on this below). Switching off Oracle or SQL Server later usually means a painful migration. Choosing PostgreSQL or MySQL up front keeps both your bill and your exit door open.

Side-by-side comparison

Engine	Licensing	Typical cost	Feature notes on RDS	Portability
PostgreSQL	Open source, free	Lowest tier	Rich SQL, JSON, extensions (PostGIS, pg_stat_statements). Some superuser actions blocked.	Very high
MySQL	Open source, free	Lowest tier	Mature, huge ecosystem. Fewer advanced SQL features than Postgres.	Very high
MariaDB	Open source, free	Lowest tier	MySQL fork; mostly MySQL-compatible. Smaller AWS feature parity.	High
Oracle	Commercial (License Included or BYOL)	High	Many features unsupported (e.g. RAC, some DBA packages, direct OS access).	Low (lock-in)
SQL Server	Commercial (License Included or BYOL)	High	No filestream, limited linked servers, edition caps on RAM/cores.	Low (lock-in)

A rough cost feel: a small open-source instance (for example db.t3.medium) runs only a few cents per hour. The same class running SQL Server “License Included” can cost several times more, and Oracle Enterprise Edition more still — the software license is the bulk of the difference, not the hardware.

Where Aurora fits in

Amazon Aurora is AWS’s own database engine, sold under the RDS umbrella. It comes in two wire-compatible flavors: Aurora MySQL-Compatible and Aurora PostgreSQL-Compatible. “Wire-compatible” means your app talks to Aurora using the normal MySQL or PostgreSQL driver and SQL — no app rewrite. Under the hood AWS replaced the storage layer with a distributed, self-healing system that replicates your data across three Availability Zones (isolated data-center groups within a Region).

What you get over plain RDS:

Faster performance and up to 15 read replicas (read-only copies) that share storage, so they catch up almost instantly.
Storage that auto-grows and is billed only for what you use.
Aurora Serverless v2, which scales capacity up and down automatically for spiky or low-traffic workloads.

Because Aurora PostgreSQL speaks standard PostgreSQL, you keep most of the portability of open source while gaining AWS-grade scaling. It is the natural “step up” from RDS PostgreSQL.

When to use which

Choice	When to use it	When NOT to
RDS PostgreSQL	Greenfield apps, rich SQL needs, lowest cost, max portability.	You already depend on Oracle-only PL/SQL packages.
RDS MySQL / MariaDB	Simple apps, existing MySQL skills or schema.	You need advanced analytics SQL — prefer Postgres.
Aurora PostgreSQL	You want Postgres but need fast replicas, big scale, or serverless.	Tiny hobby projects where plain RDS is cheaper.
Oracle / SQL Server	You are migrating an existing app that genuinely requires that engine’s features or you have an existing license.	A brand-new project — avoid the lock-in and cost.

The recommendation for greenfield

For a new project with no existing database, start with PostgreSQL — either RDS PostgreSQL for the simplest, cheapest setup, or Aurora PostgreSQL if you expect growth, want fast read replicas, or want serverless auto-scaling. You get a modern, feature-rich SQL engine, the lowest licensing cost (zero), and the freedom to move to any cloud or on-prem host later. Reach for Oracle or SQL Server only when an existing application forces your hand.

Creating an instance with a chosen engine

The engine is just a flag at create time. Pick PostgreSQL in this example.

Console steps:

Open the RDS console and choose Create database.
Select Standard create.
Under Engine options, choose PostgreSQL (or MySQL, Aurora, etc.).
Pick a Template (Production, Dev/Test, or Free tier).
Set the DB instance identifier, master username, and password.
Choose the instance class and storage, then Create database.

AWS CLI (v2):

aws rds create-db-instance \
  --db-instance-identifier devcraftly-pg \
  --engine postgres \
  --engine-version 16.4 \
  --db-instance-class db.t3.medium \
  --allocated-storage 20 \
  --master-username appadmin \
  --master-user-password 'ChangeMe-Str0ng!' \
  --vpc-security-group-ids sg-0a1b2c3d \
  --db-subnet-group-name devcraftly-subnets \
  --no-publicly-accessible

Output:

{
    "DBInstance": {
        "DBInstanceIdentifier": "devcraftly-pg",
        "Engine": "postgres",
        "EngineVersion": "16.4",
        "DBInstanceStatus": "creating",
        "DBInstanceClass": "db.t3.medium",
        "AllocatedStorage": 20,
        "MasterUsername": "appadmin"
    }
}

To list every engine AWS offers, run:

aws rds describe-db-engine-versions --query 'DBEngineVersions[].Engine' --output text

Output:

aurora-mysql  aurora-postgresql  mariadb  mysql  oracle-ee  oracle-se2  postgres  sqlserver-ee  sqlserver-se  sqlserver- web  sqlserver-ex

For repeatable infrastructure, define the engine in CloudFormation instead of clicking:

Resources:
  AppDatabase:
    Type: AWS::RDS::DBInstance
    Properties:
      Engine: postgres
      EngineVersion: "16.4"
      DBInstanceClass: db.t3.medium
      AllocatedStorage: "20"
      MasterUsername: appadmin
      MasterUserPassword: !Ref DbPassword
      PubliclyAccessible: false

Cost tip: Commercial engines bill the license per hour for as long as the instance runs — even when idle. If you spin up Oracle or SQL Server “License Included” for a quick test and forget it, the license charge dwarfs the compute. Stop or delete test commercial instances promptly, and prefer Free Tier PostgreSQL/MySQL for experiments.

Best Practices

Default to PostgreSQL for new projects; choose Aurora PostgreSQL when you need scale, fast replicas, or serverless.
Avoid commercial engines for greenfield work — the licensing cost and lock-in rarely pay off.
If you must run Oracle or SQL Server, check the RDS “unsupported features” list before designing, so you don’t depend on something RDS blocks.
Pin the --engine-version explicitly and test major-version upgrades in a clone, not in production.
Use BYOL for commercial engines only if you already own licenses and have confirmed AWS supports that license model.
Keep databases in private subnets with --no-publicly-accessible, regardless of engine.
Stop or delete non-production commercial instances quickly to avoid paying license charges around the clock.