Independent Research · Unvarnished Reviews
Amazon Aurora, Google Cloud Spanner, and Azure SQL Database are the three most-compared managed relational database services from the major cloud hyperscalers, the default choice for organizations already committed to one cloud provider and evaluating that provider's flagship database offering. This report covers a narrower, more specific question than this site's broader AWS vs. Azure vs. Google Cloud report, which models total multi-service cloud TCO; this report is about the managed relational database layer, and the real cost differences between these three that a multi-service comparison doesn't surface.
All three are credible, well-reviewed services: Aurora and Azure SQL Database both lead with MySQL/PostgreSQL or SQL Server compatibility and instance-based scaling, while Spanner leads with horizontal, globally distributed strong consistency at the architectural cost of requiring more infrastructure for the same redundancy guarantee. The finding that should change how any of the three gets budgeted: A fair comparison isn't about per-unit rate, it's about what each platform's architecture requires for production-grade high availability, and Spanner's requirement is structurally larger than the other two's.
| Platform | G2 Rating | Reviews (G2) | Note |
|---|---|---|---|
| Amazon Aurora | 4.5 / 5 | ~491 | Largest review base of the three |
| Azure SQL Database | 4.5 / 5 | ~241 | Enterprise-skewed reviewer base (39.6%-43.2%) |
| Google Cloud Spanner | 4.3 / 5 | ~44 | Smallest review base; enterprise-skewed (43.2% of reviews) |
Aurora and Azure SQL Database rate identically in user ratings, with Spanner trailing slightly behind and carrying the smallest review sample of the three. Note on sourcing for this comparison: Unlike most reports on this site, no independent transaction-benchmark data (Vendr, CostBench, or similar) exists for these three platforms, since all three bill as consumption within an organization's existing AWS, Azure, or Google Cloud account rather than as a separately negotiated SaaS contract. Pricing in this report is sourced from each vendor's published rate cards.
Aurora prices two ways. Provisioned instances are billed hourly by instance class, a representative mid-tier instance (db.r6i.large) runs approximately $0.29/hour. Aurora Serverless v2 bills per Aurora Capacity Unit (ACU) at roughly $0.06/ACU-hour, scaling automatically with load. Storage is billed separately at approximately $0.10/GB-month, and I/O requests at roughly $0.20 per million requests, a real, usage-scaling cost dimension that a flat per-GB storage rate doesn't capture.
Aurora's standard high-availability pattern uses two instances, a primary and a replica, across Availability Zones within a single region. This is Aurora's architectural baseline for production redundancy, and it's the comparison point that matters most against Spanner's very different minimum footprint.
Azure SQL Database prices per vCore, provisioned rates run approximately $0.50/hour for 2 vCores, scaling to roughly $2.52/hour at 10 vCores in representative published rate tables. A serverless compute tier is also available, billing around $0.378/vCore-hour with automatic pause-and-resume for intermittent workloads, and Azure SQL uniquely among the three offers a free tier for small workloads.
Reviewers consistently flag two things about Azure SQL Database: strong ease-of-administration and setup scores relative to competitors, and frequent complaints about cost and pricing complexity once real workloads scale beyond the entry tier, a pattern independent review aggregation calls out as one of the most-mentioned negatives across verified reviews.
Spanner prices by Processing Units (PUs) and storage: 100 PUs run approximately $0.10/hour, and 1,000 PUs (equivalent to one full node) run approximately $1/hour, roughly $720/month per node running continuously. Storage is billed at approximately $0.30/GB-month, notably higher than Aurora's or Azure SQL's per-GB storage rate.
The architectural difference that matters most for budgeting: Spanner's horizontally distributed, globally consistent design means production-grade redundancy commonly requires three or more nodes, not the two-instance pattern Aurora and Azure SQL use for HA. A minimum viable production Spanner deployment at three nodes runs approximately $2,160/month, before storage or network costs, a real, structural consequence of Spanner's architecture, not a pricing markup. This tradeoff buys different capability, Spanner's multi-region strong consistency has no equivalent in Aurora or Azure SQL without significant additional application-level engineering, but it means Spanner is the wrong platform to evaluate on a simple per-instance price comparison.
Aurora is the most familiar starting point for teams with relational database experience, with MySQL and PostgreSQL compatibility and the largest review base of the three (about 491 reviews at 4.5 out of 5).
It has the lowest-cost path to single-region high availability, with a two-instance pattern, and its compatibility layer makes real portability to other providers or self-managed instances possible.
I/O charges of roughly $0.20 per million requests scale with usage rather than data size, which a flat per-GB estimate misses.
Standard relational administration remains the team's job, and discount leverage runs through the broader AWS enterprise agreement.
Reviewers consistently flag strong ease of administration and setup, and it automates patching, backups and monitoring out of the box.
It offers the widest range of purchasing models, including provisioned, serverless with automatic pause and resume, and a free tier for small workloads.
Pricing complexity and cost growth beyond the entry tier are among the most-mentioned negatives across verified reviews.
T-SQL is Microsoft's proprietary dialect, which ties staffing and tooling to the Microsoft ecosystem.
Spanner offers horizontally scaled, globally consistent SQL with no equivalent on AWS or Azure without significant application-level engineering.
Sharding, replication and failover are automatic, so day-to-day administration is lighter than Aurora's.
A production deployment commonly needs three or more nodes, about $2,160 a month regionally and about $9,855 multi-region, before storage or network costs.
Storage is about $0.30 per GB-month, roughly three times Aurora's, and the learning curve moves into schema and query design under a consistency model with no analog elsewhere.
| Platform | Compute Basis | Representative Rate | Storage |
|---|---|---|---|
| Amazon Aurora | Instance-hourly (provisioned) or ACU-hourly (Serverless) | ~$0.29/hour (db.r6i.large); ~$0.06/ACU-hour (Serverless) | ~$0.10/GB-month |
| Azure SQL Database | vCore-hourly (provisioned or Serverless) | ~$0.50/hour (2 vCore) to ~$2.52/hour (10 vCore) | Included in tier; varies by service level |
| Google Cloud Spanner | Processing Unit-hourly (node-based) | ~$1/hour per 1,000 PU (1 node, ~$720/month) | ~$0.30/GB-month |
This scenario models each platform at its own architectural minimum for high availability, since the three don't require the same infrastructure footprint for comparable redundancy. Spanner is shown at two configurations, since its per-node rate itself depends on regional scope, a distinction independent competitive-pricing analysis (Vendr, via Cockroach Labs' published comparison data) makes explicit but that a single headline Spanner rate can obscure.
| Platform | Minimum HA Topology | Monthly Compute Cost |
|---|---|---|
| Azure SQL Database | 2 vCore provisioned tier | ~$368 |
| Amazon Aurora | 2 instances (primary + replica), db.r6i.large | ~$423 |
| Google Cloud Spanner (regional) | 3 nodes, single-region, ~$0.90-$1.80/node-hour | ~$2,160 |
| Google Cloud Spanner (multi-region) | 3 nodes, multi-region, ~$3.00-$6.00/node-hour | ~$9,855 |
Spanner's regional minimum HA deployment runs roughly 5.1x Aurora's and 5.9x Azure SQL's comparable setup. But regional deployment isn't Spanner's differentiating use case, multi-region, globally consistent deployment is, and at multi-region node rates the same 3-node minimum runs closer to 23x-27x Aurora's or Azure SQL's cost. Independent transaction-benchmark data provides a useful real-world anchor at larger scale: At a matched 32-vCPU, 1TB, multi-region configuration, Vendr's competitive analysis puts annual costs at roughly $40,000-$80,000 for Aurora (with Reserved Instances), $80,000-$120,000 for CockroachDB (negotiated), and $100,000-$150,000 for Spanner (with committed-use discounts), a real, verified data point showing Spanner's multi-region premium narrows substantially at scale and with negotiated commitments compared to the node-hour list-rate math alone. This is not evidence that Spanner is overpriced at either configuration, it reflects a different architecture built for a different problem than Aurora or Azure SQL solve for. The finding is that a buyer comparing Spanner's regional rate to Aurora's or Azure SQL's, when the actual requirement is multi-region consistency, will significantly underestimate Spanner's real cost, and a buyer who doesn't need Spanner's specific consistency guarantees is very likely paying for capability their workload doesn't require.
Pricing and architecture aren't separable here, what each platform charges for reflects what it's automating away versus what it still requires a team to manage.
| Dimension | Amazon Aurora | Google Cloud Spanner | Azure SQL Database |
|---|---|---|---|
| Implementation | MySQL/PostgreSQL-compatible, the most familiar starting point for teams with existing relational database experience; broadest engine compatibility of the three | No equivalent exists on AWS or Azure for this specific architecture, per independent comparison data; teams choosing Spanner are choosing a different distributed-SQL model, not a drop-in relational database | Independently rated easier to set up than Aurora in direct comparative review data; automates patching, backups, and monitoring out of the box |
| Admin dependency | Standard relational administration; mature tooling and the largest ecosystem of database administrators familiar with the underlying engines | Comparative review data rates Spanner easier to admin than Aurora, since sharding, replication, and failover are automatic and not team-managed; the administrative burden shifts instead into query and schema design | Lower administrative burden for routine operations, consistent with its "fully managed, intelligent" positioning; T-SQL is Microsoft's proprietary dialect, a real factor for admin tooling and staffing |
| Learning curve | Lowest of the three for teams already fluent in MySQL or PostgreSQL; the compatibility layer is the point | Documented as steeper despite lower day-to-day admin burden: Schema and query tuning for a distributed, strongly consistent architecture is independently described as complex, and the underlying TrueTime consistency model has no direct analog in Aurora or Azure SQL | Moderate; T-SQL and the broader Microsoft SQL Server engine are well-documented and widely taught, a real advantage for teams already in the Microsoft ecosystem |
| Portability and lock-in | Different from the other two: MySQL/PostgreSQL compatibility means real portability to other providers or self-managed instances if needed | The tightest lock-in of the three; Spanner's distributed consistency model and query dialect have no equivalent to migrate to outside Google Cloud | Locked to the Microsoft ecosystem and T-SQL, though migration to self-managed SQL Server or other Microsoft-adjacent options remains more available than Spanner's path out |
The real finding here: Spanner inverts the usual complexity tradeoff. Its day-to-day administrative burden is lower than Aurora's or Azure SQL's, Google manages the distributed-systems plumbing, but that plumbing being invisible doesn't mean the complexity disappeared, it moved into schema design, query patterns, and a consistency model with no equivalent elsewhere to fall back on if the team gets it wrong. Aurora and Azure SQL both ask more of day-to-day administration in exchange for a more familiar, more portable foundation. Neither tradeoff is a mistake; the question is which kind of complexity a given team is staffed to absorb.
Every finding below is independently documented and material enough to influence a purchasing decision.
Amazon Aurora
|
Azure SQL Database
|
Google Cloud Spanner
|
Choose Amazon Aurora if: You're already on AWS, need MySQL or PostgreSQL compatibility, and want the lowest-cost path to single-region high availability of the three.
Choose Azure SQL Database if: You're Microsoft-stack-first, want the widest range of purchasing models (provisioned, serverless, free tier for small workloads), and can budget for real cost growth as usage scales past the entry tier.
Choose Google Cloud Spanner if: Your application requires global, horizontally scaled strong consistency, a real technical requirement, not a nice-to-have, and you can budget for a minimum three-node production footprint from the outset rather than being surprised by it after evaluating on a per-node rate alone.
Everyone: Model your actual minimum production-grade topology, not just the headline hourly rate, before comparing these three. The gap between Aurora and Azure SQL is modest at comparable HA configurations; the gap to Spanner is real and architectural, and only makes sense to pay if Spanner's specific consistency guarantees are a real workload requirement.
Design decides what you are buying. Aurora is a MySQL and PostgreSQL-compatible relational service with an instance-based baseline, Azure SQL Database is a vCore-based SQL Server-family service with the widest purchasing models, and Spanner is a globally consistent distributed database with a structurally larger minimum footprint.
Audience decides which one fits. Aurora fits AWS organizations that want familiar engines and portability, Azure SQL fits Microsoft-stack organizations, and Spanner fits applications with a true requirement for global, horizontally scaled strong consistency.
Price depends on the plan and the unit. A minimum production high-availability deployment costs about $368 a month on Azure SQL, $423 on Aurora, $2,160 on Spanner regionally and $9,855 on Spanner multi-region, before storage and network charges. At a matched 32-vCPU, 1TB multi-region scale, annual benchmark costs narrow to roughly $40,000 to $80,000 for Aurora and $100,000 to $150,000 for Spanner.
Choose by situation:
Amazon Aurora, Google Cloud Spanner, and Azure SQL Database are all credible, well-reviewed managed relational database services, each representing its cloud provider's flagship offering. The real finding this comparison surfaces isn't which platform is cheapest per hour, it's that Spanner's architecture requires meaningfully more infrastructure than Aurora or Azure SQL for comparable production redundancy, roughly 5x the monthly cost at regional scale, and considerably more once multi-region distribution, Spanner's actual differentiating use case, is factored in. That premium buys real, differentiated capability for workloads that need it, and is a real, avoidable overspend for workloads that don't.
Free trials and test-drives. AWS gives new customers $100 in credits at sign-up, plus up to $100 more for using services such as Amazon RDS, and Aurora PostgreSQL is available under the AWS Free Tier. Google Cloud Spanner offers a 90-day free trial instance with 10 GB of storage and up to five databases, followed by a 30-day grace period, and new customers set up a billing account with a payment method first. Azure SQL Database offers 100,000 vCore seconds and 32 GB of storage free each month for the lifetime of the subscription, for up to 10 databases, with no SLA. Load a representative dataset and test failover, not just queries.