AWS Builder Center
Aurora DSQL actually does multiregion strong consistency

Aurora DSQL actually does multiregion strong consistency

A look at Aurora DSQL, active-active writes across regions with strong consistency, the PostgreSQL features it drops, and what the DPU bill looked like

Cloud and DevOps Engineer
I wrote a row in Virginia and read it back in Oregon in the same breath. No replica lag to wait out, no "eventually it'll show up," no read-replica routing logic. The row was just there, on the other side of the country, the instant the write committed.
That's the pitch for Amazon Aurora DSQL, and it's the part that made me stop and actually test it instead of nodding along to the launch post. DSQL is a serverless distributed SQL database that speaks PostgreSQL, scales compute and storage independently, and drops to zero when nobody's using it. You get DynamoDB-style scaling with a Postgres wire protocol, and the cross-region reads don't lie to you about what's committed.
So I built a two-region cluster, ran writes in both directions, forced a write conflict on purpose, and watched the bill accrue by the minute. Here's what happened, including the parts that'll bite you.

What DSQL Is

DSQL is a new database engine that speaks the PostgreSQL wire protocol. It isn't Aurora PostgreSQL rebadged, and it isn't a proxy sitting in front of Postgres, whatever the "Aurora" in the name suggests. Your  psql , your driver, and most of your SQL keep working, while the machinery underneath is built from scratch.
There's no single leader. Every endpoint in every region serves both reads and writes. Run a multiregion cluster and you get a writable endpoint in each linked region plus a witness region that holds a copy of the data for quorum and stays read-only. All of it presents as one logical database, and if you lose a region the other keeps taking writes with no data loss.
There's nothing to size either. No instances, no VPC to wire up, no security groups, no storage to provision. Compute, commit throughput, and storage each scale on their own. The endpoints are public and access is gated by IAM, so you authenticate with an IAM auth token instead of a password you have to store somewhere.
The engine is largely written in Rust, and the AWS team has been unusually open about how it works. A few pieces are worth knowing before the demo, because they explain the behavior you'll see:
  • Every transaction gets its own Query Processor, a micro-VM that parses, plans, and runs your SQL in isolation. It reads the clock from the Amazon Time Sync Service at the start and pins the transaction to that timestamp for snapshot isolation.
  • Writes are spooled in the Query Processor and only submitted at commit time to the adjudicators. The key space is sharded across them, and each key is owned by exactly one adjudicator globally. They're the referees that decide whether a commit collides with anyone else.
  • A committed transaction gets written to a durable journal. A component called the crossbar then fans those writes out to the storage nodes that own the relevant keys.
That last part is what makes multiregion work. When you commit in one region, the post-image and the set of keys you touched get sent to the peer region's transaction leader, which checks them against everything in flight there before confirming. Conflicts get caught at commit time, globally, not smoothed over after the fact.
Multiregion active-active architecture: a client hits the Query Processor micro-VM in each region, which commits through adjudicators to a durable journal and crossbar out to storage nodes, with a post-image and conflict-check arrow between the two regions and a read-only witness region for quorum


Building the Cluster

Creating a multiregion cluster is a three-step handshake, not one call. You create a cluster in the first region and tell it the witness region, create the second cluster pointing at the first as a peer, then update the first to point back at the second. Once they know about each other, both move from  PENDING_SETUP  to  ACTIVE .
I used us-east-1 and us-west-2 as the writable pair, with us-east-2 as the witness.
# Region 1: create with the witness region set, no peers yet
aws dsql create-cluster --region us-east-1 \
--no-deletion-protection-enabled \
--multi-region-properties '{"witnessRegion":"us-east-2"}'

# Region 2: create pointing at region 1 as a peer
aws dsql create-cluster --region us-west-2 \
--no-deletion-protection-enabled \
--multi-region-properties '{"witnessRegion":"us-east-2","clusters":["arn:aws:dsql:us-east-1:...:cluster/<id1>"]}'

# Back to region 1: add region 2 as the peer to complete the link
aws dsql update-cluster --region us-east-1 --identifier <id1> \
--multi-region-properties '{"witnessRegion":"us-east-2","clusters":["arn:aws:dsql:us-west-2:...:cluster/<id2>"]}'
Deletion protection is on by default. I turned it off at creation because this was a throwaway demo and I wanted a clean teardown. Leave it on for anything real.
Both clusters reached  ACTIVE  in about two minutes. Describe either one and it lists the other as a peer plus the witness region. That's the whole setup. No instance class, no storage size, no engine version to pick.
The DSQL console for the N. Virginia cluster, Active, with the Peers tab showing us-west-2 (Oregon) as a Cluster peer and us-east-2 (Ohio) as the Witness

Connecting is  psql  with an IAM token as the password:
export PGSSLMODE=require
TOKEN=$(aws dsql generate-db-connect-admin-auth-token \
--hostname "$ENDPOINT" --region us-east-1)
PGPASSWORD="$TOKEN" psql -h "$ENDPOINT" -U admin -d postgres -p 5432
The token expires after 15 minutes. You don't hand-roll this in a real app. Use the DSQL connector for your language ( psycopg , node-postgres, pgx, and JDBC all have one), because a bare driver works fine right up until the token expires and then starts failing on every new connection, which people reliably misdiagnose as a DSQL bug. The connector refreshes the token for you and uses  sslmode=verify-full  by default.
DSQL reports itself as PostgreSQL 16.

The Demo That Matters: Write Here, Read There

I created a table on the us-east-1 endpoint and put a couple of rows in it.
CREATE TABLE orders (
id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
product text NOT NULL,
qty int NOT NULL,
created_region text NOT NULL,
created_at timestamptz NOT NULL DEFAULT now()
);
Then the actual test. Insert a row through the Virginia endpoint, and immediately, in the next command, read it through the Oregon endpoint 3,000 miles away:
=== WRITE on us-east-1 ===
INSERT 0 1
=== READ immediately from us-west-2 ===
product | qty | created_region | created_at
-------------------------+-----+----------------+-------------------------------
cross-region-1786624409 | 42 | us-east-1 | 2026-08-13 12:33:32.280795+00
(1 row)
There it is. The write committed in one region and the read in the other region saw it right away. I ran it the other direction too, writing on us-west-2 and reading on us-east-1, and got the same result. Both endpoints take writes, and a committed write shows up everywhere the moment it commits. No replica is catching up here. It's a single database that happens to live in two places at once.
A psql session: an INSERT on the us-east-1 endpoint, then the same row read back immediately from the us-west-2 endpoint

If you've used DynamoDB global tables, sit with why this is different. Global tables replicate asynchronously and settle conflicting writes with last-writer-wins. A write in one region shows up in another after a short delay, and two writers hitting the same item can quietly clobber each other. DSQL does the opposite. The commit itself is coordinated across regions, so you get one consistent answer instead of a race you have to design around.

Concurrency Without Locks

DSQL doesn't take row locks while your transaction runs. It uses optimistic concurrency control instead. Every transaction proceeds as if it's alone, and only at commit does the database check whether anyone else touched the same rows since you started. First commit wins, and the loser gets told to try again.
I forced it. Two sessions, both updating the same row. Session B committed first, then session A tried to commit a moment later:
[B] UPDATE 1
[B] COMMIT
[A] UPDATE 1
[A] ERROR: change conflicts with another transaction (OC000)
Session A's transaction was aborted, not blocked, and the final value reflected only B's write. That error code,  OC000  under SQLSTATE  40001 , is the one your application has to expect and retry. There's a sibling too,  OC001 , for schema conflicts like an async index going valid mid-transaction. Both are transient, and both mean the same thing to your code: back off a little and run the transaction again.
This is a real design consequence, not a footnote. A slow client can't hold a lock and stall everyone behind it, because there are no locks to hold, and deadlocks don't happen. The cost is that your write paths need retry logic. The language connectors ship a retry helper that wraps a transaction and re-runs it on  40001  with backoff, so in practice you wrap your writes once and move on. If you're hammering a hot row with raw SQL from many clients, though, expect conflicts and make your retries idempotent.

Where PostgreSQL Compatibility Ends

"PostgreSQL-compatible" is doing real work in that sentence. The honest version: most of your SQL is fine, and a specific list of things isn't. I tested the edges instead of trusting the marketing, and here's what broke, with the actual errors.
 SERIAL  columns don't exist:
ERROR: type "serial" does not exist
Bare sequences get rejected unless you give them a large cache:
ERROR: CREATE SEQUENCE is not supported without an explicit cache size.
please define CACHE greater than or equal to 65536 or equal to 1
Foreign keys aren't supported at all:
ERROR: FOREIGN KEY constraint not supported
You can't create an index the normal way on a table that already has data:
ERROR: unsupported mode. please use CREATE INDEX ASYNC.
And you can't mix schema changes with data changes in one transaction:
ERROR: ddl and dml are not supported in the same transaction
Once you know the rules, they're livable. Indexes build online with  CREATE INDEX ASYNC , which returns a job id and works in the background. Sequences work with  CACHE 65536 . Identity and UUID keys stand in for  SERIAL . Multi-statement DML transactions, aggregates,  GROUP BY , views, joins, and  gen_random_uuid()  all worked without complaint.
The two that actually change how you design are foreign keys and the row limits. No foreign keys means referential integrity moves into your application. You check that the parent row exists before inserting the child, and you check for dependents before deleting. There are caps to respect too. A transaction can touch at most 3,000 rows, write at most 10 MiB, and it has to finish inside 5 minutes, so bulk work gets chunked. Those are the current defaults and they can change, so check the docs before you build a migration around a specific number.
None of this is hidden, and it's the tradeoff for a database that scales horizontally and commits across regions. It does mean DSQL isn't a drop-in for an app that leans on Postgres extensions, triggers, or foreign keys. Figure out which camp you're in before you commit to a migration.

What It Costs, and the Scale-to-Zero Part

Pricing has two parts: a Distributed Processing Unit (DPU) for database activity, and storage per GB-month. There's a free tier, and rates vary by region and change over time, so pull the current numbers from the AWS pricing page instead of trusting a figure in a blog post. What I can show you is the shape of it, measured.
DSQL publishes per-minute metrics to CloudWatch under  AWS/AuroraDSQL . Across my whole session on the us-east-1 cluster,  TotalDPU  came out like this:
TotalDPU (per minute): 0.13 3.18 5.10 5.45 6.84
Five datapoints. Roughly 20 DPU total for an afternoon of building tables, running the consistency tests, and forcing a conflict. The part that matters more than the number: those five are the only datapoints that exist. The minutes I wasn't running queries have no datapoints at all. The metric isn't zero during idle time, it's absent, because the cluster consumed nothing. That's scale-to-zero, and it's the whole economic argument for spiky or intermittent workloads. You're not paying for a provisioned instance sitting warm overnight.
Two other metrics told a story worth noting.  WriteDPU  and  MultiRegionWriteDPU  were identical on my cluster, because in a multiregion setup every write is a multiregion write. Cross-region replication isn't a separate thing you switch on, it's what a commit is. And  OccConflicts  read exactly  1 , matching the single conflict I forced. The metrics lined up with reality, which is more than I can say for some services.
CloudWatch graph of TotalDPU, MultiRegionWriteDPU, and OccConflicts for the us-east-1 cluster at Sum over 1-minute periods: flat at the floor while the cluster is idle, then a run of per-minute spikes once the workload runs


When to Use It, and When Not To

The honest decision guide, having now used it:
Reach for DSQL when you want relational data with SQL and transactions, your access is OLTP-shaped (lots of small reads and writes, not giant analytical scans), and either your traffic is spiky enough that scale-to-zero saves real money or you actually need active-active writes across regions with strong consistency. That last requirement is the one nothing else on AWS satisfies cleanly. If your product is "same database, low latency, correct answers, in more than one region," this is a short list of one.
Stay on Aurora PostgreSQL when you need the full Postgres feature set: extensions, foreign keys enforced by the engine, triggers, stored procedures, big transactions, analytical queries that scan millions of rows. Aurora gives you a real PostgreSQL with all of it, at the cost of managing an instance and living with a single-region writer (or the constraints of its multi-writer setup). If you're migrating an existing Postgres app that leans on the parts DSQL drops, the rewrite might cost more than the scaling is worth.
Stay on DynamoDB when your access pattern is key-value or document, you want single-digit-millisecond latency at any scale, and you don't need SQL or joins. DynamoDB is superb at what it does. Just know its multiregion story is eventual and last-writer-wins, so if you were reaching for global tables specifically to get consistent writes across regions, DSQL fits that one requirement better.
The framing that helped me: DynamoDB and DSQL scale in similar ways, but DSQL keeps SQL and cross-region consistency. Aurora PostgreSQL keeps every Postgres feature, but not the serverless scaling or the active-active regions. You're picking which two of those three you need most.

Who It's For

If you're building a new OLTP service, you want SQL, and you either care about correctness across regions or have bursty traffic, DSQL is worth a real prototype. The build cost is tiny. I had a working two-region cluster in minutes and spent about 20 DPU proving it works. The friction isn't operational, it's in your schema and your write paths: no foreign keys, retry your commits, chunk your bulk writes.
If your app depends on the Postgres features DSQL leaves out, or your workload is analytical, or you're happy on one region and just want a managed database, the older options are still the right call. Don't migrate for the novelty.
I went in skeptical of "distributed SQL" as a category, because the phrase usually hides a painful asterisk somewhere. The cross-region write test did more to convince me than any diagram could. A row written in Virginia, readable in Oregon the same instant, from one Postgres-speaking database that bills nothing while it sleeps. That's a new option worth having, and it's worth knowing which of your problems it actually fits.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article