
I Tested It After Aurora DSQL Was Announced to Improve Write Throughput by Up to 50%
This page has been translated by machine translation. View original
Introduction
On November 19, 2026, AWS announced higher write throughput for Amazon Aurora DSQL.
Thanks to improvements in the storage layer, write throughput is said to increase by up to 50%.
This article presents the results of testing the behavior on a new Aurora DSQL cluster, as well as checking the performance changes on an existing cluster that has been running for about 3 months with Database Insights enabled.
Test Environment
- Region: ap-northeast-1 (new single-region cluster)
- Connection: psql (admin role)
- Time measurement: psql's
\timing(client-side time, including communication time). Each condition was run 3 times - Version: PostgreSQL 16 (result of
select version())
Test Details
INSERT
I created two tables with small row sizes, and INSERTed 3,000 rows and 3,001 rows generated with generate_series, each in a single transaction.
CREATE TABLE t_3000 (id bigint PRIMARY KEY, val text NOT NULL);
CREATE TABLE t_3001 (id bigint PRIMARY KEY, val text NOT NULL);
\timing on
\echo === 3000 rows
BEGIN;
INSERT INTO t_3000 SELECT g, 'x' FROM generate_series(1, 3000) AS g;
COMMIT;
SELECT count(*) AS rows_t_3000 FROM t_3000;
\echo === 3001 rows
BEGIN;
INSERT INTO t_3001 SELECT g, 'x' FROM generate_series(1, 3001) AS g;
COMMIT;
SELECT count(*) AS rows_t_3001 FROM t_3001;
| Rows INSERTed per transaction | Result | Error | Rows after COMMIT | INSERT statement time (3 runs; for failures, until the error is returned) |
|---|---|---|---|---|
| 3,000 | Success (INSERT 0 3000) | None | 3,000 | 188 / 98 / 103 ms |
| 3,001 | Failure (ROLLBACK) | ERROR: transaction row limit exceeded | 0 | 73 / 36 / 60 ms |
The quotas documentation states that the number of rows that can be modified in a single transaction is 3,000. The results this time matched that description.
UPDATE
I created the table t_10000 and loaded 10,000 rows in 4 batches of 2,500 rows.
Creating the table and loading 10,000 rows
CREATE TABLE t_10000 (id bigint PRIMARY KEY, val text NOT NULL);
\echo === populate 10000 rows (2500 x 4)
BEGIN;
INSERT INTO t_10000 SELECT g, 'x' FROM generate_series(1, 2500) AS g;
COMMIT;
BEGIN;
INSERT INTO t_10000 SELECT g, 'x' FROM generate_series(2501, 5000) AS g;
COMMIT;
BEGIN;
INSERT INTO t_10000 SELECT g, 'x' FROM generate_series(5001, 7500) AS g;
COMMIT;
BEGIN;
INSERT INTO t_10000 SELECT g, 'x' FROM generate_series(7501, 10000) AS g;
COMMIT;
SELECT count(*) AS rows_t_10000 FROM t_10000;
The UPDATE SQL is as follows.
\timing on
\echo === UPDATE 3000 rows
BEGIN;
UPDATE t_10000 SET val = 'y' WHERE id <= 3000;
COMMIT;
SELECT count(*) AS updated FROM t_10000 WHERE val = 'y';
| Rows UPDATEd per transaction | Result | Error | Rows updated after COMMIT | UPDATE statement time (3 runs) |
|---|---|---|---|---|
| 3,000 | Success (UPDATE 3000) | None | 3,000 | 748 / 736 / 729 ms |
Performance Changes on an Existing Cluster
I also checked whether write-related metrics changed on an existing cluster.
The target is a single-region cluster in us-west-2. It has a table that holds 50,000 to 100,000 vectors as JSONB, and there were no changes on the application side.
I looked at about 3 months of data, from August 19 to November 19, 2026, which was the period available, using Database Insights and CloudWatch metrics.
Changes in CommitLatency
The metric that changed was CommitLatency (the P50 of the commit phase of write transactions). The distribution by period, limited to hours with 10 to 200 write transactions per hour, is as follows.
| Period | Hours | 25th percentile | Median | 75th percentile |
|---|---|---|---|---|
| Oct 20 – 27 | 114 | 10.3 ms | 11.2 ms | 12.6 ms |
| Oct 28 – Nov 4 | 113 | 8.0 ms | 8.6 ms | 9.2 ms |
| Nov 5 – 12 | 99 | 7.7 ms | 8.4 ms | 9.3 ms |
| Nov 13 – 19 | 98 | 7.7 ms | 8.4 ms | 9.1 ms |
Starting from October 28, about 3 weeks before the announcement date (November 19), CommitLatency improved by about 25%.
Summary
It was announced that the write throughput of Amazon Aurora DSQL improves by up to 50%.
On an Aurora DSQL cluster that had been running continuously since before the announcement, CommitLatency improved by about 25% in late October with no changes on the application side. It is reasonable to infer that it is benefiting from the improved write throughput.
On the same day, PL/pgSQL support for Aurora DSQL was also released.
If DSQL's I/O or transaction performance was an issue for you, please give it another try.
