# Transactions

Database transactions are logical units of work that group operations into all-or-nothing execution and provide ACID guarantees such as consistency, isolation, and durability.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Handling large volume of transactions with AWS Lambda Managed Instances

DevFeed: [Handling large volume of transactions with AWS Lambda Managed Instances](<https://devfeed.tech/articles/handling-large-volume-of-transactions-with-aws-lambda-managed-instances-144755.md>)

Original publisher: [Read original article](<https://aws.amazon.com/blogs/compute/handling-large-volume-of-transactions-with-aws-lambda-managed-instances/>)

Author: Mythili Annamalai Sekar

Published: 2026-11-19T21:20:28Z

Content type: tutorial

Language: en

Sources: [AWS Compute Blog](<https://devfeed.tech/sources/aws-compute-blog.md>)

Topics: [Amazon DynamoDB](<https://devfeed.tech/topics/amazon-dynamodb.md>), [Amazon EC2](<https://devfeed.tech/topics/amazon-ec2.md>), [Amazon ElastiCache](<https://devfeed.tech/topics/amazon-elasticache.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>)

Tags: [advanced-300](<https://devfeed.tech/tags/advanced-300.md>), [aws](<https://devfeed.tech/tags/aws.md>), [aws-lambda](<https://devfeed.tech/tags/aws-lambda.md>), [can](<https://devfeed.tech/tags/can.md>), [capacity](<https://devfeed.tech/tags/capacity.md>), [compute](<https://devfeed.tech/tags/compute.md>), [concert](<https://devfeed.tech/tags/concert.md>), [handling](<https://devfeed.tech/tags/handling.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [lambda](<https://devfeed.tech/tags/lambda.md>), [large](<https://devfeed.tech/tags/large.md>), [managed](<https://devfeed.tech/tags/managed.md>), [post](<https://devfeed.tech/tags/post.md>), [reference](<https://devfeed.tech/tags/reference.md>), [run](<https://devfeed.tech/tags/run.md>), [sample](<https://devfeed.tech/tags/sample.md>), [technical-how-to](<https://devfeed.tech/tags/technical-how-to.md>), [test](<https://devfeed.tech/tags/test.md>), [this](<https://devfeed.tech/tags/this.md>), [transactions](<https://devfeed.tech/tags/transactions.md>), [volume](<https://devfeed.tech/tags/volume.md>), [with](<https://devfeed.tech/tags/with.md>)

### AI overview

AWS Lambda Managed Instances runs Lambda functions on EC2 capacity in the customer's account, with AWS managing provisioning, scaling, patching, and routing. Its warm execution environments can be scaled ahead of scheduled bursts and back down afterward; the article's ticketing sample reports 40,000 requests per second for 120 seconds across tests from 5,000 to 40,000 requests per second, with p99 latency within a 3 ms band. The design uses a Valkey atomic queue counter, DynamoDB conditional seat holds with 180-second TTLs, and a transaction that confirms bookings and writes records atomically. Setup requires AWS CLI, SAM, Python 3.13+, a VPC, and network access to DynamoDB and CloudWatch; peak tests also need higher EC2 vCPU and API Gateway throttle quotas. Managed Instances uses EC2 pricing plus a 15% management fee; the article estimates about $37 per simulated burst.

### Source excerpt

AWS Lambda Managed Instances keeps compute capacity warm before a predictable traffic burst and scales it back down afterward. This post walks through a concert-ticketing reference implementation that sustains 40,000 transactions per second for 120 seconds, with a deployable sample you can run, test, and clean up.

## Three Records Your Support Team Needs After a Background Job Fails

DevFeed: [Three Records Your Support Team Needs After a Background Job Fails](<https://devfeed.tech/articles/three-records-your-support-team-needs-after-a-background-job-fails-143910.md>)

Original publisher: [Read original article](<https://hackernoon.com/three-records-your-support-team-needs-after-a-background-job-fails?source=rss>)

Author: Khakan Ali

Published: 2026-11-19T14:37:05Z

Content type: tutorial

Language: en

Sources: [HackerNoon](<https://devfeed.tech/sources/hackernoon.md>)

Topics: [Transactions](<https://devfeed.tech/topics/transactions.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [transaction-log](<https://devfeed.tech/topics/transaction-log.md>), [Job](<https://devfeed.tech/topics/job.md>)

Tags: [acceptance](<https://devfeed.tech/tags/acceptance.md>), [background](<https://devfeed.tech/tags/background.md>), [background-jobs](<https://devfeed.tech/tags/background-jobs.md>), [build](<https://devfeed.tech/tags/build.md>), [catalog](<https://devfeed.tech/tags/catalog.md>), [change](<https://devfeed.tech/tags/change.md>), [code](<https://devfeed.tech/tags/code.md>), [commit](<https://devfeed.tech/tags/commit.md>), [complete](<https://devfeed.tech/tags/complete.md>), [crash](<https://devfeed.tech/tags/crash.md>), [crash-recovery](<https://devfeed.tech/tags/crash-recovery.md>), [crashes](<https://devfeed.tech/tags/crashes.md>), [customer](<https://devfeed.tech/tags/customer.md>), [data](<https://devfeed.tech/tags/data.md>), [database](<https://devfeed.tech/tags/database.md>), [database-transactions](<https://devfeed.tech/tags/database-transactions.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [fault-tolerance](<https://devfeed.tech/tags/fault-tolerance.md>), [idempotent-background-jobs](<https://devfeed.tech/tags/idempotent-background-jobs.md>), [idempotent-processing](<https://devfeed.tech/tags/idempotent-processing.md>), [learn](<https://devfeed.tech/tags/learn.md>), [python](<https://devfeed.tech/tags/python.md>), [python-sqlite-importer](<https://devfeed.tech/tags/python-sqlite-importer.md>), [retries](<https://devfeed.tech/tags/retries.md>), [sqlite](<https://devfeed.tech/tags/sqlite.md>), [tests](<https://devfeed.tech/tags/tests.md>), [transactions](<https://devfeed.tech/tags/transactions.md>)

### AI overview

The local Python/SQLite importer makes a failed job inspectable by saving three records: the accepted import's exact bytes and hash, each row committed with its catalog change in one transaction, and an outcome derived from completed-row counts. Reusing the same import ID and bytes safely skips completed rows in this single-database design; changed bytes under that ID are rejected. Process-exit tests show that a retry completes work after a pre-commit failure, and after a post-commit failure it preserves the committed row without rewriting it, even when acknowledgment was absent. Competing local workers produced exactly two catalog writes for two rows, with SQLite serializing writes and a 15-second lock wait. The example ran locally with Python 3.13.3 and SQLite 3.49.2. It does not establish safety for remote side effects, distributed systems, power loss, or production deployment; an uncertain remote action requires provider idempotency behavior and reconciliation.

### Source excerpt

Learn how to build a crash-recoverable Python and SQLite importer using transactions, idempotent retries, and tests for interrupted background jobs.

## Databases Demystified Chapter 5 - Transactions Part 2 | Blog | Fivetran

DevFeed: [Databases Demystified Chapter 5 - Transactions Part 2 | Blog | Fivetran](<https://devfeed.tech/articles/databases-demystified-chapter-5-transactions-part-2-blog-fivetran-140212.md>)

Original publisher: [Read original article](<https://wf.fivetran.com/blog/databases-demystified-transactions-part-2>)

Author: Michael Kaminsky

Published: 2026-11-18T03:38:23Z

Content type: article

Language: en

Sources: [Fivetran Blog](<https://devfeed.tech/sources/fivetran-blog.md>)

Topics: [Transactions](<https://devfeed.tech/topics/transactions.md>), [race-condition](<https://devfeed.tech/topics/race-condition.md>), [acid](<https://devfeed.tech/topics/acid.md>), [Deadlock](<https://devfeed.tech/topics/deadlock.md>), [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>)

Tags: [concurrency](<https://devfeed.tech/tags/concurrency.md>), [databases](<https://devfeed.tech/tags/databases.md>), [deadlock](<https://devfeed.tech/tags/deadlock.md>), [isolation](<https://devfeed.tech/tags/isolation.md>), [transactions](<https://devfeed.tech/tags/transactions.md>)

### AI overview

Database isolation reduces race conditions in concurrent transactions, but higher isolation usually requires more locks and can slow transactions or create contention and deadlocks. The article outlines dirty, non-repeatable, and phantom reads, and ranks common isolation levels from Serializable to Read Uncommitted. Locks can apply to rows, columns, or tables; locking less data can reduce blocking, while deadlocks can occur when transactions hold locks each other needs. Isolation behavior varies between databases, so the article advises checking documentation and testing parallel workloads, including under production-like contention, and balancing data correctness against performance.

### Source excerpt

Learn about the relationship between isolation and concurrency.

## I benchmarked Snowflake Postgres mirroring for two days. Here are the numbers.

DevFeed: [I benchmarked Snowflake Postgres mirroring for two days. Here are the numbers.](<https://devfeed.tech/articles/i-benchmarked-snowflake-postgres-mirroring-for-two-days-here-are-the-numbers-136382.md>)

Original publisher: [Read original article](<https://medium.com/snowflake/i-benchmarked-snowflake-postgres-mirroring-for-two-days-here-are-the-numbers-b50eba22b8de?source=rss----34b6daafc07---4>)

Author: Ondřej Blaha

Published: 2026-11-17T01:00:34Z

Content type: article

Language: en

Sources: [Snowflake Builders](<https://devfeed.tech/sources/snowflake-builders.md>)

Topics: [Snowflake streaming data architecture](<https://devfeed.tech/topics/snowflake-streaming-data-architecture.md>), [elt](<https://devfeed.tech/topics/elt.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [data type](<https://devfeed.tech/topics/data-type.md>), [Apache Iceberg](<https://devfeed.tech/topics/apache-iceberg.md>)

Tags: [analytics](<https://devfeed.tech/tags/analytics.md>), [arrays](<https://devfeed.tech/tags/arrays.md>), [batch](<https://devfeed.tech/tags/batch.md>), [cost](<https://devfeed.tech/tags/cost.md>), [data-engineering](<https://devfeed.tech/tags/data-engineering.md>), [gotchas](<https://devfeed.tech/tags/gotchas.md>), [impact](<https://devfeed.tech/tags/impact.md>), [latency](<https://devfeed.tech/tags/latency.md>), [load](<https://devfeed.tech/tags/load.md>), [mirroring](<https://devfeed.tech/tags/mirroring.md>), [numbers](<https://devfeed.tech/tags/numbers.md>), [oltp](<https://devfeed.tech/tags/oltp.md>), [operations](<https://devfeed.tech/tags/operations.md>), [pipeline](<https://devfeed.tech/tags/pipeline.md>), [postgres](<https://devfeed.tech/tags/postgres.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [postgresql-replication](<https://devfeed.tech/tags/postgresql-replication.md>), [refresh](<https://devfeed.tech/tags/refresh.md>), [replication](<https://devfeed.tech/tags/replication.md>), [snowflake](<https://devfeed.tech/tags/snowflake.md>), [source](<https://devfeed.tech/tags/source.md>), [two-days](<https://devfeed.tech/tags/two-days.md>)

### AI overview

On a Snowflake Postgres STANDARD_M instance in one AWS region, mirrored rows reached the near-real-time `TABLE$live` view in about 26 seconds at the median and 37 seconds at p90 across refresh intervals; the regular table could lag by up to one interval. Under the tested write load, moving from a 30-second to a 2-minute interval cut apply-task cost 73%, while small OLTP transactions showed little source impact and batch inserts into mirrored tables were 20-30% slower. The author recommends starting at 2 minutes, using `$live` for operational freshness, adding primary keys before mirroring, and committing bulk loads in chunks of up to 100,000 rows. Important limits include lossy mappings for some PostgreSQL types, `$changes` history being cleared by column changes, and `RESTART_MIRROR` triggering a full table copy. Results are from one instance size and region with limited repetitions, and are not an SLA.

### Source excerpt

Latency distributions, cost per refresh interval, impact on the source database, bulk loads and operations. Measured on the smallest instance that supports mirroring. Snowflake Postgres, managed PostgreSQL running inside a Snowflake account, has been generally available since 24 February 2026, and data mirroring into Snowflake followed on 15 October 2026. I didn't just want to see that it works. I wanted real numbers under a simulated load, so that I can tell clients how it actually behaves and compare the cost with what we had expected. The marketing says "seconds" and "sub-minute", and nobody had published a latency distribution, a cost per interval or the impact on the source database, so I spent two days measuring them. TL;DR Freshness: new rows show up in TABLE$live after ~26 s (median), ~37 s (p90), no matter whether the refresh interval is 30 seconds or 10 minutes. The table itself lags behind $live by up to one refresh interval. Cost: the serverless apply task cost 0.063 credits/h idle at a 30-second interval and 0.25 credits/h under a steady write load. Switching to 2 minutes cut the loaded cost by 73 %, to 10 minutes by 88 %. Source impact: small OLTP transactions barely notice the mirror. Batch inserts into a mirrored table were 20-30 % slower than into a non-mirrored table on the same instance. Operations: SUSPEND_MIRROR took 2.5-4.7 s under load, RESTART_MIRROR re-copies every table despite saying "soft", adding an 8M-row table to a running mirror took under a minute, and the replication slot survived every suspend/resume of the instance. Gotchas: numeric without precision becomes FLOAT, json/jsonb become TEXT, 2-D arrays become NULL, PostgreSQL refuses ADD COLUMN ... DEFAULT <volatile> on mirrored tables, any ADD, DROP or RENAME COLUMN wipes that table's $changes history, and tables without a primary key turn insert-only. Why this matters Every team that runs an application on Postgres and analytics in Snowflake owns a pipeline between the two. It is usu

## DuckDB has an answer to "bloated" database messages

DevFeed: [DuckDB has an answer to "bloated" database messages](<https://devfeed.tech/articles/duckdb-has-an-answer-to-bloated-database-messages-134453.md>)

Original publisher: [Read original article](<https://thenewstack.io/duckdb-quack-database-protocol/>)

Author: Jennifer Riggins

Published: 2026-11-15T15:05:56Z

Content type: news

Language: en

Sources: [The New Stack](<https://devfeed.tech/sources/the-new-stack.md>)

Topics: [DuckDB](<https://devfeed.tech/topics/duckdb.md>), [Database](<https://devfeed.tech/topics/database.md>), [SQL](<https://devfeed.tech/topics/sql.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>)

Tags: [2-0-0](<https://devfeed.tech/tags/2-0-0.md>), [amsterdam](<https://devfeed.tech/tags/amsterdam.md>), [application](<https://devfeed.tech/tags/application.md>), [argument](<https://devfeed.tech/tags/argument.md>), [authentication](<https://devfeed.tech/tags/authentication.md>), [aws-marketplace](<https://devfeed.tech/tags/aws-marketplace.md>), [backend-development](<https://devfeed.tech/tags/backend-development.md>), [batches](<https://devfeed.tech/tags/batches.md>), [big-data](<https://devfeed.tech/tags/big-data.md>), [cli](<https://devfeed.tech/tags/cli.md>), [client](<https://devfeed.tech/tags/client.md>), [clients](<https://devfeed.tech/tags/clients.md>), [column](<https://devfeed.tech/tags/column.md>), [columnar](<https://devfeed.tech/tags/columnar.md>), [command-line](<https://devfeed.tech/tags/command-line.md>), [commands](<https://devfeed.tech/tags/commands.md>), [data](<https://devfeed.tech/tags/data.md>), [database](<https://devfeed.tech/tags/database.md>), [databases](<https://devfeed.tech/tags/databases.md>), [duckdb](<https://devfeed.tech/tags/duckdb.md>), [messages](<https://devfeed.tech/tags/messages.md>), [podcast](<https://devfeed.tech/tags/podcast.md>), [protocols](<https://devfeed.tech/tags/protocols.md>), [results](<https://devfeed.tech/tags/results.md>), [sponsor-amazon-web-services-aws](<https://devfeed.tech/tags/sponsor-amazon-web-services-aws.md>), [sponsor-aws-marketplace](<https://devfeed.tech/tags/sponsor-aws-marketplace.md>), [sponsored](<https://devfeed.tech/tags/sponsored.md>), [sponsored-podcast](<https://devfeed.tech/tags/sponsored-podcast.md>), [video](<https://devfeed.tech/tags/video.md>)

### AI overview

Quack is DuckDB's HTTP-based client/server protocol, released in DuckDB 2.0.0 LTS, designed to reduce message overhead and stream query results as columnar data. Rather than serializing rows with repeated column details or waiting for a full query to finish, it sends DuckDB data chunks as the engine produces them, so clients can consume results while execution continues. The article says this can keep memory use small. The release adds SQL CONNECT for remote servers, -serve and -connect CLI options, and concurrent client writes using DuckDB's MVCC isolation. Further server-side stability improvements were expected in patch releases.

### Source excerpt

Older database protocols were built before big data. Some still send results row by row, repeating details like column names The post DuckDB has an answer to "bloated" database messages appeared first on The New Stack.

## Databricks is a Leader and positioned highest in execution in the 2026 Gartner® Magic Quadrant™ for Data Lakehouse Platforms

DevFeed: [Databricks is a Leader and positioned highest in execution in the 2026 Gartner® Magic Quadrant™ for Data Lakehouse Platforms](<https://devfeed.tech/articles/databricks-is-a-leader-and-positioned-highest-in-execution-in-the-2026-gartner-magic-quadranttm-for-data-lakehouse-platforms-136417.md>)

Original publisher: [Read original article](<https://www.databricks.com/blog/databricks-leader-and-positioned-highest-execution-2026-gartnerr-magic-quadranttm-data>)

Author: Kaitlin Baumgardner; Kevin Balaji; Brianna Helm; Jonathan Keller; Susan Pierce

Published: 2026-11-14T18:15:02Z

Content type: article

Language: en

Sources: [Databricks](<https://devfeed.tech/sources/databricks.md>)

Topics: [databricks](<https://devfeed.tech/topics/databricks.md>), [Data Management](<https://devfeed.tech/topics/data-management.md>), [data-engineering](<https://devfeed.tech/topics/data-engineering.md>), [deltalake](<https://devfeed.tech/topics/deltalake.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [DataOps](<https://devfeed.tech/topics/dataops.md>), [AI Infrastructure](<https://devfeed.tech/topics/ai-infrastructure.md>), [Serverless](<https://devfeed.tech/topics/serverless.md>), [BigQuery](<https://devfeed.tech/topics/bigquery.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [2026](<https://devfeed.tech/tags/2026.md>), [3](<https://devfeed.tech/tags/3.md>), [about](<https://devfeed.tech/tags/about.md>), [acid](<https://devfeed.tech/tags/acid.md>), [affiliates](<https://devfeed.tech/tags/affiliates.md>), [ai](<https://devfeed.tech/tags/ai.md>), [company](<https://devfeed.tech/tags/company.md>), [data](<https://devfeed.tech/tags/data.md>), [data-lakehouse](<https://devfeed.tech/tags/data-lakehouse.md>), [databricks](<https://devfeed.tech/tags/databricks.md>), [decades](<https://devfeed.tech/tags/decades.md>), [enterprises](<https://devfeed.tech/tags/enterprises.md>), [execution](<https://devfeed.tech/tags/execution.md>), [gartner](<https://devfeed.tech/tags/gartner.md>), [gartner-magic-quadranttm](<https://devfeed.tech/tags/gartner-magic-quadranttm.md>), [lakebase](<https://devfeed.tech/tags/lakebase.md>), [lakehouse](<https://devfeed.tech/tags/lakehouse.md>), [lakehouse-architecture](<https://devfeed.tech/tags/lakehouse-architecture.md>), [leader](<https://devfeed.tech/tags/leader.md>), [ltap](<https://devfeed.tech/tags/ltap.md>), [magic](<https://devfeed.tech/tags/magic.md>), [operational](<https://devfeed.tech/tags/operational.md>), [platforms](<https://devfeed.tech/tags/platforms.md>)

### AI overview

Databricks argues that AI workloads need operational and analytical data on one governed foundation. Its Lake Transactional/Analytical Processing (LTAP) architecture pairs Lakebase Postgres for ACID transactions with lakehouse engines for analytics, both reading one durable copy in open formats such as Delta Lake and Apache Iceberg under Unity Catalog. The company says this avoids pipelines and mirrored tables while giving analytics fresh application data without slowing transactions. Lakebase Postgres uses separated, serverless compute and storage on cloud object storage, scales compute to zero, and supports instant database branching. Databricks cites PRADA Group's reported KPI delivery at about 130 times faster and infrastructure costs about 50% lower. It also says Gartner named Databricks a Leader with the highest execution scores in its 2026 Data Lakehouse Platforms Magic Quadrant and the only Visionary in its Cloud Operational Database Management Systems Magic Quadrant. These are vendor-reported claims; the text includes Gartner's disclaimer that its research is not an endorsement.

### Source excerpt

AI is pulling analytical and operational data togetherFor decades, enterprises have...

## Improve RDS Proxy multiplexing for PostgreSQL, Part 1: Common causes

DevFeed: [Improve RDS Proxy multiplexing for PostgreSQL, Part 1: Common causes](<https://devfeed.tech/articles/improve-rds-proxy-multiplexing-for-postgresql-part-1-common-causes-133437.md>)

Original publisher: [Read original article](<https://aws.amazon.com/blogs/database/improve-rds-proxy-multiplexing-for-postgresql-part-1-common-causes/>)

Author: Pavel Rabinovich

Published: 2026-11-13T21:08:09Z

Content type: article

Language: en

Sources: [AWS Database Blog](<https://devfeed.tech/sources/aws-database-blog.md>)

Topics: [RDS for PostgreSQL](<https://devfeed.tech/topics/rds-for-postgresql.md>), [connection pool](<https://devfeed.tech/topics/connection-pool.md>), [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>), [Amazon Aurora](<https://devfeed.tech/topics/amazon-aurora.md>), [Amazon RDS](<https://devfeed.tech/topics/amazon-rds.md>), [Amazon CloudWatch](<https://devfeed.tech/topics/amazon-cloudwatch.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>)

Tags: [advanced-300](<https://devfeed.tech/tags/advanced-300.md>), [amazon](<https://devfeed.tech/tags/amazon.md>), [amazon-aurora](<https://devfeed.tech/tags/amazon-aurora.md>), [amazon-cloudwatch](<https://devfeed.tech/tags/amazon-cloudwatch.md>), [cloudwatch](<https://devfeed.tech/tags/cloudwatch.md>), [fragmentation](<https://devfeed.tech/tags/fragmentation.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [metrics](<https://devfeed.tech/tags/metrics.md>), [multiplexing](<https://devfeed.tech/tags/multiplexing.md>), [pool](<https://devfeed.tech/tags/pool.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [proxy](<https://devfeed.tech/tags/proxy.md>), [rds](<https://devfeed.tech/tags/rds.md>), [rds-for-postgresql](<https://devfeed.tech/tags/rds-for-postgresql.md>), [technical-how-to](<https://devfeed.tech/tags/technical-how-to.md>), [transactions](<https://devfeed.tech/tags/transactions.md>)

### AI overview

RDS Proxy multiplexing for PostgreSQL is reduced when sessions are pinned, client identities fragment the pool, or transactions remain open. CloudWatch indicators help distinguish them: elevated session-pinned connections suggest pinning; many backend connections with low borrowing and pinning can indicate fragmentation; sustained borrowing and open transactions point to transactions held too long. Fixes include upgrading the PostgreSQL JDBC driver to 42.7.x or newer, removing application SET statements, setting Spark JDBC writes to isolationLevel=NONE, and using InitQuery for shared session defaults. Standardize username, database, and ApplicationName among clients that should share a pool, while preserving separate users when privilege or audit needs require them. Commit promptly or enable autocommit where explicit transaction control is unnecessary. PostgreSQL targets do not support the proxy's SET pinning filter, and CloudWatch gauges can miss short-lived borrow cycles.

### Source excerpt

RDS Proxy multiplexes many client connections across a small pool of database connections, but connection pinning, pool fragmentation, and uncommitted transactions can silently disable that benefit for PostgreSQL workloads. Part 1 shows how to recognize each condition with Amazon CloudWatch metrics and the fix that restores multiplexing.

## Multi-statement transactions for Apache Iceberg tables in Amazon Redshift

DevFeed: [Multi-statement transactions for Apache Iceberg tables in Amazon Redshift](<https://devfeed.tech/articles/multi-statement-transactions-for-apache-iceberg-tables-in-amazon-redshift-133388.md>)

Original publisher: [Read original article](<https://aws.amazon.com/blogs/big-data/multi-statement-transactions-for-apache-iceberg-tables-in-amazon-redshift/>)

Author: Shiyu Xu

Published: 2026-11-13T19:32:46Z

Content type: release

Language: en

Sources: [AWS Big Data Blog](<https://devfeed.tech/sources/aws-big-data-blog.md>)

Topics: [Amazon Redshift](<https://devfeed.tech/topics/amazon-redshift.md>), [Apache Iceberg](<https://devfeed.tech/topics/apache-iceberg.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [Amazon S3 Tables](<https://devfeed.tech/topics/amazon-s3-tables.md>), [AWS Glue](<https://devfeed.tech/topics/aws-glue.md>), [Amazon S3](<https://devfeed.tech/topics/amazon-s3.md>)

Tags: [airflow](<https://devfeed.tech/tags/airflow.md>), [amazon-redshift](<https://devfeed.tech/tags/amazon-redshift.md>), [announcements](<https://devfeed.tech/tags/announcements.md>), [apache-iceberg](<https://devfeed.tech/tags/apache-iceberg.md>), [apache-iceberg-tables](<https://devfeed.tech/tags/apache-iceberg-tables.md>), [atomic](<https://devfeed.tech/tags/atomic.md>), [foundational-100](<https://devfeed.tech/tags/foundational-100.md>), [snapshot](<https://devfeed.tech/tags/snapshot.md>), [transactions](<https://devfeed.tech/tags/transactions.md>)

### AI overview

Amazon Redshift Patch 206 and later can group multiple DML statements against one Apache Iceberg table into a single `BEGIN ... COMMIT`, publishing one atomic snapshot. The transaction can include an audit before commit; failures and rollbacks publish no changes. All writes must target the same table using the same reference name, while reads may include uncommitted writes and each table's version is fixed on its first read. Run Iceberg DDL separately. Uncommitted intermediate files can become orphans; S3 Tables removes unreferenced files by default, while Glue tables require the orphan file deletion optimizer enabled in advance. In the reported test, batching 25 small statements reduced total runtime by 14.77% for INSERT and 11.29% for DELETE; heavy data work showed no meaningful speedup. At 32 concurrent writers, four-INSERT transactions achieved 3.59 times the committed-statement rate of auto-commit. Results vary with statement size, partitioning, and contention.

### Source excerpt

Amazon Redshift now supports multi-statement transactions for Apache Iceberg tables, so you can run several DML statements against one Iceberg table inside a single BEGIN...COMMIT and publish them as one atomic Iceberg snapshot. This post explains why one commit per statement makes multi-step pipelines fragile, what you can run in a transaction, and how it performs.

## Auriga: Harness-Governed LLM Agents for Effective Throughput Optimization in Execute-Order-Validate Permissioned Blockchains

DevFeed: [Auriga: Harness-Governed LLM Agents for Effective Throughput Optimization in Execute-Order-Validate Permissioned Blockchains](<https://devfeed.tech/articles/auriga-harness-governed-llm-agents-for-effective-throughput-optimization-in-execute-order-validate-permissioned-blockchains-132690.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.14945>)

Author: Xiao Zhang, Tianyang Wang, Fangtao Gu, Haoxiang Sun, Puwei Wang, Jinchuan Chen

Published: 2026-11-13T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Databases](<https://devfeed.tech/sources/arxiv-databases.md>)

Topics: [Agent Harness](<https://devfeed.tech/topics/agent-harness.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>)

Tags: [ablation](<https://devfeed.tech/tags/ablation.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ast](<https://devfeed.tech/tags/ast.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [capacity](<https://devfeed.tech/tags/capacity.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [contracts](<https://devfeed.tech/tags/contracts.md>), [cs-db](<https://devfeed.tech/tags/cs-db.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [effective](<https://devfeed.tech/tags/effective.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [execution](<https://devfeed.tech/tags/execution.md>), [experience](<https://devfeed.tech/tags/experience.md>), [exploration](<https://devfeed.tech/tags/exploration.md>), [fabric](<https://devfeed.tech/tags/fabric.md>), [framework](<https://devfeed.tech/tags/framework.md>), [harness](<https://devfeed.tech/tags/harness.md>), [llm](<https://devfeed.tech/tags/llm.md>), [llm-agents](<https://devfeed.tech/tags/llm-agents.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [throughput](<https://devfeed.tech/tags/throughput.md>)

### AI overview

Auriga aims to improve effective throughput in Execute-Order-Validate blockchains by jointly tuning configuration and preventing transaction conflicts before execution. Its harness-governed agents explore parameters, evaluate saturation, and consolidate experience, while the harness controls tool and memory access and retains termination authority. Separately, an LLM derives symbolic AST templates from smart contracts offline; at runtime, the scheduler predicts read-write sets without executing transactions and groups them to avoid conflicts. Across three benchmarks with conflict rates up to 70%, the authors report up to 6.0x the effective throughput of default Hyperledger Fabric and 2.0x that of the strongest baseline. The abstract also reports discovery of undocumented parameter dependencies and ablations indicating contributions from both subsystems.

### Source excerpt

arXiv:2611.14945v1 Announce Type: new Abstract: Effective throughput, the product of raw throughput and transaction success rate, determines the useful capacity of Execute-Order-Validate blockchains such as Hyperledger Fabric. Most prior work either tunes configurations to raise raw throughput, requiring many costly redeployments, or controls conflicts to raise the success rate, repairing them only after execution with kernel modifications. The few joint approaches tune only a small set of parameters and still rely on kernel changes to resolve conflicts. To address these challenges, we present Auriga, a non-invasive framework that jointly optimizes both factors through sample-efficient LLM-guided configuration search and pre-execution conflict prevention. A harness-governed multi-agent architecture coordinates LLM agents for parameter exploration, saturation-aware evaluation, and experience consolidation, with the harness controlling tool and memory access and retaining termination authority. For transaction scheduling, an LLM extracts symbolic AST templates from smart contracts offline. At runtime, the scheduler predicts read-write sets without executing them and partitions transactions into conflict-free groups. Across three benchmarks and conflict rates up to 70%, Auriga improves effective throughput by up to 6.0 times over default Fabric and 2.0 times over the strongest baseline. The tuning agent also discovers undocumented parameter dependencies, and ablation studies show the independent contributions of both subsystems.

## Omakase: Execution Congestion Control through Conflict-Graph Integration in Multi-Proposer Blockchain

DevFeed: [Omakase: Execution Congestion Control through Conflict-Graph Integration in Multi-Proposer Blockchain](<https://devfeed.tech/articles/omakase-execution-congestion-control-through-conflict-graph-integration-in-multi-proposer-blockchain-131554.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.17184>)

Author: Dakai Kang, Ray Neiheiser, Alberto Sonnino, Eleftherios Kokoris Kogias, Mohammad Sadoghi

Published: 2026-11-13T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Databases](<https://devfeed.tech/sources/arxiv-databases.md>), [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [Blockchain](<https://devfeed.tech/topics/blockchain.md>), [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [Parallelism](<https://devfeed.tech/topics/parallelism.md>), [graph theory](<https://devfeed.tech/topics/graph-theory.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>)

Tags: [blockchain](<https://devfeed.tech/tags/blockchain.md>), [concurrency-control](<https://devfeed.tech/tags/concurrency-control.md>), [congestion-control](<https://devfeed.tech/tags/congestion-control.md>), [consensus](<https://devfeed.tech/tags/consensus.md>), [cs-db](<https://devfeed.tech/tags/cs-db.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [ethereum](<https://devfeed.tech/tags/ethereum.md>), [execution](<https://devfeed.tech/tags/execution.md>), [graph](<https://devfeed.tech/tags/graph.md>), [integration](<https://devfeed.tech/tags/integration.md>), [optimistic-concurrency](<https://devfeed.tech/tags/optimistic-concurrency.md>), [order](<https://devfeed.tech/tags/order.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [pipeline](<https://devfeed.tech/tags/pipeline.md>), [prediction](<https://devfeed.tech/tags/prediction.md>), [protocols](<https://devfeed.tech/tags/protocols.md>), [scheduler](<https://devfeed.tech/tags/scheduler.md>), [stable](<https://devfeed.tech/tags/stable.md>), [state](<https://devfeed.tech/tags/state.md>), [synthetic](<https://devfeed.tech/tags/synthetic.md>)

### AI overview

Omakase targets execution bottlenecks in multi-proposer blockchains by integrating conflict graphs across blocks committed in a round. Replicas pre-execute only the blocks they propose; a greedy scheduler combines per-block graphs when a lightweight heuristic predicts more parallelism, and a graph-aware OCC executor admits transactions in dependency order. The authors report a 2.47x speedup over sequential execution on 15,000 Ethereum mainnet blocks (~2.4 million transactions) and synthetic workloads. Compared with running a whole round as one optimistic window, it matches mean throughput and is more stable under high contention; integration bounds optimistic work in flight. Integration has a cost, though overlapping it with execution across rounds hides 94% of its measured cost in the validator pipeline. These findings are reported in the supplied abstract.

### Source excerpt

arXiv:2611.17184v1 Announce Type: cross Abstract: As multi-proposer protocols push consensus throughput, transaction execution has become the dominant bottleneck in blockchains. Layer-1 blockchains parallelize execution either pessimistically (Solana, Sui), requiring upfront state-access declarations and serializing contended transactions, or optimistically (Aptos, Sei, Monad), resolving dependencies at run time but suffering cascading aborts under contention. Both treat blocks in isolation, leaving inter-block parallelism unexploited and most cores idle. We introduce Omakase, a parallel execution framework that combines pre-execution, inter-block conflict-graph integration, and graph-aware Optimistic Concurrency Control (OCC). Replicas use idle cores to pre-execute only the blocks they propose, spreading prediction work across concurrent proposers. After building per-block conflict graphs and identifying their hot resources, a greedy scheduler integrates graphs across the blocks committed in a round, keeping an integration only when a lightweight balance heuristic predicts a parallelism gain. A graph-aware OCC executor then runs the integrated graph, admitting transactions in dependency order, which eliminates aborts when the predicted graph is exact and reduces re-executions when it is not. On 15,000 Ethereum mainnet blocks (~2.4M transactions) and synthetic workloads with configurable contention, Omakase reaches a 2.47x speedup over sequential execution, well above single-block OCC and graph-aware baselines. Against the strongest alternative, which runs the whole round as one optimistic window, Omakase matches mean throughput but is markedly more stable under high contention, because integration bounds how much optimistic work is in flight: this is the congestion control of our title. Integration is not free, but overlapping it with execution across rounds hides 94% of its measured cost in the validator pipeline.

## Where LLM Agents Get Stuck Debugging Databases: Access More Than Reasoning

DevFeed: [Where LLM Agents Get Stuck Debugging Databases: Access More Than Reasoning](<https://devfeed.tech/articles/where-llm-agents-get-stuck-debugging-databases-access-more-than-reasoning-131743.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.17304>)

Author: Gustavo Pinto

Published: 2026-11-13T05:00:00Z

Content type: opinion

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Claude Code](<https://devfeed.tech/topics/claude-code.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.md>), [api](<https://devfeed.tech/tags/api.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [code](<https://devfeed.tech/tags/code.md>), [coding](<https://devfeed.tech/tags/coding.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [context](<https://devfeed.tech/tags/context.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [data](<https://devfeed.tech/tags/data.md>), [database](<https://devfeed.tech/tags/database.md>), [databases](<https://devfeed.tech/tags/databases.md>), [deadlock](<https://devfeed.tech/tags/deadlock.md>), [debug](<https://devfeed.tech/tags/debug.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [environment](<https://devfeed.tech/tags/environment.md>), [llm](<https://devfeed.tech/tags/llm.md>), [llm-agents](<https://devfeed.tech/tags/llm-agents.md>), [reasoning](<https://devfeed.tech/tags/reasoning.md>)

### AI overview

In eight production database incidents, access to runtime state was the most pervasive obstacle for Claude Code when diagnosing concurrency-related failures. All five concurrency-dependent incidents involved an access gap, including missing live lock views, complete deadlock reports, read-only execution, or explicit environment context; four also involved reasoning errors. The agent's incorrect hypotheses fit the evidence available to it, and each wrong guess cost a deploy-and-observe cycle. The three incidents not dependent on concurrency required no additional access. The authors propose a forensics layer within existing security controls, combining a safe interrogation API, a lock-and-deadlock flight recorder, and a production replay harness.

### Source excerpt

arXiv:2611.17304v1 Announce Type: new Abstract: Large language model (LLM) coding agents are increasingly asked not only to write code but to debug running systems from live runtime data. We report a field observation of one such agent (Claude Code) as it diagnosed eight database incidents in a production message-dispatch engine. In every incident whose root cause depended on runtime concurrency, the agent announced a cause, shipped a fix, and later walked it back, and each wrong guess cost a deploy-and-observe cycle. Mapping each incident to what the agent lacked, we find that access to production state was the most pervasive bottleneck. The missing access included live lock views, untruncated deadlock reports, read-only execution, and an explicit environment context. An access gap was present in all five concurrency-dependent incidents: alone in one, and in four combined with a reasoning error such as anchoring on an early cause, incomplete exploration of the configuration, or a misreading of the code's transaction semantics. The three incidents that did not depend on concurrency needed nothing beyond what the agent already had. Within the incidents, the agent's wrong hypotheses were consistent with the evidence it could see; they were not fabrications. We argue that the next step for production-debugging agents is a forensics layer that gives the agent the access it lacks inside existing security controls. Such a layer would combine a safe interrogation API, a lock-and-deadlock flight recorder, and a production replay harness.

## Dispelling LTAP myths

DevFeed: [Dispelling LTAP myths](<https://devfeed.tech/articles/dispelling-ltap-myths-130978.md>)

Original publisher: [Read original article](<https://www.databricks.com/blog/dispelling-ltap-myths>)

Author: Sergey Melnik

Published: 2026-11-12T21:49:43Z

Content type: article

Language: en

Sources: [Databricks](<https://devfeed.tech/sources/databricks.md>)

Topics: [read-replica](<https://devfeed.tech/topics/read-replica.md>), [Debezium Connector](<https://devfeed.tech/topics/debezium-connector.md>), [etl](<https://devfeed.tech/topics/etl.md>), [Analytics Pipeline](<https://devfeed.tech/topics/analytics-pipeline.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [DuckDB](<https://devfeed.tech/topics/duckdb.md>), [JOIN](<https://devfeed.tech/topics/join.md>)

Tags: [about](<https://devfeed.tech/tags/about.md>), [addition](<https://devfeed.tech/tags/addition.md>), [after](<https://devfeed.tech/tags/after.md>), [all](<https://devfeed.tech/tags/all.md>), [also](<https://devfeed.tech/tags/also.md>), [alter](<https://devfeed.tech/tags/alter.md>), [analytics](<https://devfeed.tech/tags/analytics.md>), [api](<https://devfeed.tech/tags/api.md>), [apis](<https://devfeed.tech/tags/apis.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [array](<https://devfeed.tech/tags/array.md>), [availability](<https://devfeed.tech/tags/availability.md>), [bookkeeping](<https://devfeed.tech/tags/bookkeeping.md>), [buffer](<https://devfeed.tech/tags/buffer.md>), [build](<https://devfeed.tech/tags/build.md>), [but](<https://devfeed.tech/tags/but.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [lakebase](<https://devfeed.tech/tags/lakebase.md>), [monolith](<https://devfeed.tech/tags/monolith.md>), [myths](<https://devfeed.tech/tags/myths.md>), [post](<https://devfeed.tech/tags/post.md>)

### AI overview

LTAP stores one logical copy of each Postgres table in the lake, while heap pages, indexes, and caches serve as tiers for fast operational access. The excerpt distinguishes these tiers from CDC replicas, which create a separately queryable database that can drift, omit tables, or fall behind. For analytics, heap pages support point lookups while Parquet supports scans; queries merge recent committed pages with the materialized snapshot at a shared LSN, keeping multi-table reads consistent even when Parquet lags. LTAP compacts changed pages in parallel rather than replaying every WAL row event. The author says logical replication remains useful for migrations, upgrades, and cutovers, and notes that APIs for reading changes since a watermark are still being developed.

### Source excerpt

Reynold Xin's post "From monolith to Lakebase to LTAP" explained what LTAP is and...

## A database per agent: how Turso and Neon give different answers

DevFeed: [A database per agent: how Turso and Neon give different answers](<https://devfeed.tech/articles/a-database-per-agent-how-turso-and-neon-give-different-answers-132575.md>)

Original publisher: [Read original article](<https://turso.tech/blog/a-database-per-agent-how-turso-and-neon-give-different-answers>)

Author: Jeff Olson

Published: 2026-11-12T00:00:00Z

Content type: comparison

Language: en

Sources: [Turso](<https://devfeed.tech/sources/turso-blog.md>)

Topics: [Turso](<https://devfeed.tech/topics/turso.md>), [Database](<https://devfeed.tech/topics/database.md>), [AI Agent](<https://devfeed.tech/topics/ai-agent.md>), [Platform API](<https://devfeed.tech/topics/platform-api.md>), [self-hosted databases vs managed services](<https://devfeed.tech/topics/self-hosted-databases-vs-managed-services.md>), [Embedded Replicas](<https://devfeed.tech/topics/embedded-replicas.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [ai-companies](<https://devfeed.tech/tags/ai-companies.md>), [api](<https://devfeed.tech/tags/api.md>), [app](<https://devfeed.tech/tags/app.md>), [auth](<https://devfeed.tech/tags/auth.md>), [aws](<https://devfeed.tech/tags/aws.md>), [backend](<https://devfeed.tech/tags/backend.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [bill](<https://devfeed.tech/tags/bill.md>), [compute](<https://devfeed.tech/tags/compute.md>), [costs](<https://devfeed.tech/tags/costs.md>), [database](<https://devfeed.tech/tags/database.md>), [file](<https://devfeed.tech/tags/file.md>), [lightweight](<https://devfeed.tech/tags/lightweight.md>), [neon](<https://devfeed.tech/tags/neon.md>), [postgres](<https://devfeed.tech/tags/postgres.md>), [project](<https://devfeed.tech/tags/project.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [turso](<https://devfeed.tech/tags/turso.md>)

### AI overview

Neon and Turso both support a database per agent, but charge and operate at different levels. Neon gives each agent a Postgres project with separate compute and storage; compute suspends after five idle minutes and resumes on demand, while usage is billed by CU-hour and storage. It offers project caps and an approval-based Agent Plan, and its copy-on-write branches include the project's auth, files, and functions--useful when agents need copies of an entire production app. Turso treats each SQLite-compatible database as a file managed by shared servers, with no compute allocation per database; paid plans include unlimited databases, and bursty workloads incur storage and read/write costs. Turso also supports local embedded databases with cloud sync, BYOC deployment, and per-database customer-managed keys. The article positions Turso for many small, intermittent agent databases, while recommending Neon when whole-app branching is central and Supabase Postgres for workloads requiring Postgres. Its Supabase roadmap and pricing details reflect the text's stated dates and may change.

### Source excerpt

Neon and Turso both give every agent its own database. On Neon, that is a Postgres project with its own compute. On Turso, it is a lightweight database that costs about as much as a file.

## Break your dependencies on purpose: introducing Quarkus Resiliency Testing

DevFeed: [Break your dependencies on purpose: introducing Quarkus Resiliency Testing](<https://devfeed.tech/articles/break-your-dependencies-on-purpose-introducing-quarkus-resiliency-testing-135957.md>)

Original publisher: [Read original article](<https://quarkus.io/blog/quarkus-resiliency-testing/>)

Author: Georgios Andrianakis (https://twitter.com/geoand86)

Published: 2026-11-12T00:00:00Z

Content type: tutorial

Language: en

Sources: [Quarkus - Supersonic Subatomic Java](<https://devfeed.tech/sources/quarkus-supersonic-subatomic-java.md>)

Topics: [Test automation](<https://devfeed.tech/topics/test-automation.md>), [Quarkus](<https://devfeed.tech/topics/quarkus.md>), [Chaos Engineering](<https://devfeed.tech/topics/chaos-engineering.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [connection pool](<https://devfeed.tech/topics/connection-pool.md>)

Tags: [client](<https://devfeed.tech/tags/client.md>), [clients](<https://devfeed.tech/tags/clients.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [database](<https://devfeed.tech/tags/database.md>), [docker](<https://devfeed.tech/tags/docker.md>), [examples](<https://devfeed.tech/tags/examples.md>), [exception](<https://devfeed.tech/tags/exception.md>), [exceptions](<https://devfeed.tech/tags/exceptions.md>), [extension](<https://devfeed.tech/tags/extension.md>), [failure](<https://devfeed.tech/tags/failure.md>), [fallback](<https://devfeed.tech/tags/fallback.md>), [fault-injection](<https://devfeed.tech/tags/fault-injection.md>), [inventory](<https://devfeed.tech/tags/inventory.md>), [junit](<https://devfeed.tech/tags/junit.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [quarkus](<https://devfeed.tech/tags/quarkus.md>), [resiliency](<https://devfeed.tech/tags/resiliency.md>), [retries](<https://devfeed.tech/tags/retries.md>), [services](<https://devfeed.tech/tags/services.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

Quarkus Resiliency Testing injects network and resource failures into `@QuarkusTest` runs so real clients and application configuration face hangs, broken responses, and unavailable dependencies. `NetworkFaultsProfile` routes supported outbound connections through in-process proxies; tests can check bounded waits and recovery, bulkheads, payment retries with stable idempotency keys, JDBC timeouts and pool exhaustion, stale connections, transaction rollback, and Kafka publishing behavior. The examples show that retries, timeouts, exception mapping, and transaction choices determine customer-visible outcomes; fault injection alone does not provide resilience. The article also describes disk-full and DNS faults, Dev UI exploration, and an outbox alternative when orders must be accepted during Kafka outages. Requirements include Quarkus 4 and Java 21. Limits include plaintext HTTP/1.x for HTTP faults, Linux-only `connectTimeout()`, and no `@QuarkusIntegrationTest` support; some Dev Services still require Docker.

### Source excerpt

Imagine a customer placing an order. Your service reserves stock, charges their card, and stores the result. On a normal day, each step takes milliseconds and the customer sees a confirmation. Now imagine inventory accepts the connection but never answers. Or the payment provider charges the card just before the connection breaks. Or the database stops responding while your application is holding a connection from its pool. These failures demand different responses. Waiting longer can use up your workers; retrying can charge the customer twice; catching an exception does nothing if the client never throws one. A happy-path test tells you little about any of them. Quarkus Resiliency Testing lets you reproduce these conditions in a @QuarkusTest, using your application's real clients and configuration. Let's follow that order through four failure scenarios and turn each one into a test. The examples are excerpts from the resilient-orders sample, which includes the endpoints, supporting classes and complete tests. Put the failure on the wire Add the test dependency: <dependency> <groupId>io.quarkiverse.resiliencytesting</groupId> <artifactId>quarkus-resiliency-testing-junit</artifactId> <version>0.6.0</version> <scope>test</scope> </dependency> With NetworkFaultsProfile, the extension discovers supported outbound connections from Quarkus configuration, including Dev Services, and redirects them through proxies inside the test JVM. The proxy normally relays traffic. During a fault, the real client encounters the broken connection and reacts with its own timeouts, retries and exceptions. A mock that throws an exception can check a fallback; this also exercises the client configuration that determines whether, and when, that fallback is reached. The fault injection needs no separate container or sidecar; dependencies such as the sample's PostgreSQL Dev Service can still need Docker. 1. Inventory stops answering The customer clicks "Place order", but inventory never respond

## PROTECT-DB: Protecting Data using Replicated State Machines: Efficient Corruption Detection & Recovery

DevFeed: [PROTECT-DB: Protecting Data using Replicated State Machines: Efficient Corruption Detection & Recovery](<https://devfeed.tech/articles/protect-db-protecting-data-using-replicated-state-machines-efficient-corruption-detection-recovery-125659.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2605.11953>)

Author: Anant Utgikar, S. Sudarshan

Published: 2026-11-10T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>), [arXiv: Databases](<https://devfeed.tech/sources/arxiv-databases.md>)

Topics: [Data Management](<https://devfeed.tech/topics/data-management.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [transaction-log](<https://devfeed.tech/topics/transaction-log.md>), [threat detection](<https://devfeed.tech/topics/threat-detection.md>), [Disaster Recovery](<https://devfeed.tech/topics/disaster-recovery.md>)

Tags: [blockchain](<https://devfeed.tech/tags/blockchain.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [corruption](<https://devfeed.tech/tags/corruption.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-db](<https://devfeed.tech/tags/cs-db.md>), [data](<https://devfeed.tech/tags/data.md>), [database](<https://devfeed.tech/tags/database.md>), [databases](<https://devfeed.tech/tags/databases.md>), [detection](<https://devfeed.tech/tags/detection.md>), [efficiency](<https://devfeed.tech/tags/efficiency.md>), [execution](<https://devfeed.tech/tags/execution.md>), [extension](<https://devfeed.tech/tags/extension.md>), [log](<https://devfeed.tech/tags/log.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [recovery](<https://devfeed.tech/tags/recovery.md>), [repair](<https://devfeed.tech/tags/repair.md>), [replica](<https://devfeed.tech/tags/replica.md>), [state-machines](<https://devfeed.tech/tags/state-machines.md>), [study](<https://devfeed.tech/tags/study.md>), [system](<https://devfeed.tech/tags/system.md>), [transactions](<https://devfeed.tech/tags/transactions.md>)

### AI overview

PROTECT-DB uses Byzantine-fault-tolerant replicated state machines built on a deterministic PostgreSQL extension to protect database state. Replicas deterministically execute transactions recorded in a shared log or blockchain. The system aims to detect corruption quickly and repair it while transaction execution continues. The abstract says a performance study demonstrates efficiency and practicality but provides no measurements or detailed results.

### Source excerpt

arXiv:2605.11953v2 Announce Type: replace Abstract: Data is critical for the operation of any organization and needs to be protected, especially against attacks that compromise the state of the database. In this paper, we explore an approach based on Byzantine-fault tolerant replicated state machines, built on top of a deterministic extension of PostgreSQL. Each replica deterministically executes transactions recorded in a shared log/blockchain. Our focus is on creating a practical system that is designed for efficient and quick detection of corruption, as well as quick repair concurrent with execution of transactions. We also present a performance study showing the efficiency and practicality of our approach. We believe our work lays the foundations for the practical use of the BFT replicated state machine approach in the context of databases.

## Safe by Accident: Crash-Testing LLM-Written Code

DevFeed: [Safe by Accident: Crash-Testing LLM-Written Code](<https://devfeed.tech/articles/safe-by-accident-crash-testing-llm-written-code-127237.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.10585>)

Author: Afridi Mahmud, Md. As-Aid Rahman, Rifat Shahriyar

Published: 2026-11-10T05:00:00Z

Content type: news

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Transactions](<https://devfeed.tech/topics/transactions.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [Code](<https://devfeed.tech/topics/code.md>), [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [backend](<https://devfeed.tech/tags/backend.md>), [code](<https://devfeed.tech/tags/code.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [crash](<https://devfeed.tech/tags/crash.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [database](<https://devfeed.tech/tags/database.md>), [email](<https://devfeed.tech/tags/email.md>), [environment](<https://devfeed.tech/tags/environment.md>), [evaluations](<https://devfeed.tech/tags/evaluations.md>), [file](<https://devfeed.tech/tags/file.md>), [library](<https://devfeed.tech/tags/library.md>), [llm](<https://devfeed.tech/tags/llm.md>), [model](<https://devfeed.tech/tags/model.md>), [python](<https://devfeed.tech/tags/python.md>), [repair](<https://devfeed.tech/tags/repair.md>), [safety](<https://devfeed.tech/tags/safety.md>), [sqlite3](<https://devfeed.tech/tags/sqlite3.md>), [testing](<https://devfeed.tech/tags/testing.md>), [transaction](<https://devfeed.tech/tags/transaction.md>)

### AI overview

The study finds that apparent crash safety in LLM-written database code can depend on sqlite3's default transaction behavior. Researchers injected crashes before database, file, and email calls and evaluated 9,100 solutions from ten models across 24 backend tasks. Of database code that survived every crash under sqlite3's default mode, 54% was left partially updated in autocommit mode; this occurred across all models, including code with conn: blocks that do not open transactions. Telling models to use autocommit did not change local code models' output, while API models' unsafe share fell by 30 percentage points. Explicitly asking for crash safety helped every model, and strong models repaired nearly all unsafe code, though they often wrote safe code only when prompted. The abstract suggests testing under a less forgiving configuration to distinguish code-designed safety from protection supplied by the library.

### Source excerpt

arXiv:2611.10585v1 Announce Type: new Abstract: Evaluations of LLM-written code run it once, in one environment, and credit the code with whatever passes. We show that this credit can belong to the environment. We crashed LLM-written backend code just before each database, file and email call, re-ran it as an operator would, and judged the result under two transaction modes of Python's sqlite3: the default, in which the library quietly opens a transaction, and autocommit, in which it does not. Across 9,100 solutions from ten models on 24 backend tasks, more than half (54%) of the database code that survives every crash in the default mode is left half-updated in autocommit mode. This holds for every model, and it hides in ordinary code, including with conn: blocks that look like transactions but open none. Telling the model that its connection is in autocommit mode does not change what the local code models write, while the API models' unsafe share falls by 30 points. Asking for crash safety helps every model, and strong models repair nearly all unsafe code, but often write safe code only when asked. Thus, much of the crash safety that LLM-written database code appears to have is borrowed from the library rather than designed into it, and a second test under a less forgiving configuration reveals the difference.

## PostgreSQL CDC into Apache Iceberg with OLake Go and Apache Polaris

DevFeed: [PostgreSQL CDC into Apache Iceberg with OLake Go and Apache Polaris](<https://devfeed.tech/articles/postgresql-cdc-into-apache-iceberg-with-olake-go-and-apache-polaris-123566.md>)

Original publisher: [Read original article](<https://www.dremio.com/blog/postgresql-cdc-into-apache-iceberg-with-olake-go-and-apache-polaris/>)

Author: Alex Merced

Published: 2026-11-09T13:42:00Z

Content type: tutorial

Language: en

Sources: [Dremio](<https://devfeed.tech/sources/dremio.md>)

Topics: [Apache Iceberg](<https://devfeed.tech/topics/apache-iceberg.md>), [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>), [implementation](<https://devfeed.tech/topics/implementation.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>)

Tags: [access-control](<https://devfeed.tech/tags/access-control.md>), [apache-iceberg](<https://devfeed.tech/tags/apache-iceberg.md>), [apache-polaris](<https://devfeed.tech/tags/apache-polaris.md>), [cdc](<https://devfeed.tech/tags/cdc.md>), [credentials](<https://devfeed.tech/tags/credentials.md>), [data-lakehouse](<https://devfeed.tech/tags/data-lakehouse.md>), [dremio-blog-open-data-insights](<https://devfeed.tech/tags/dremio-blog-open-data-insights.md>), [go](<https://devfeed.tech/tags/go.md>), [oauth](<https://devfeed.tech/tags/oauth.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [rest](<https://devfeed.tech/tags/rest.md>), [state](<https://devfeed.tech/tags/state.md>), [validation](<https://devfeed.tech/tags/validation.md>)

### AI overview

OLake Go can stream PostgreSQL logical replication changes into Iceberg tables registered in Apache Polaris. The pipeline relies on PostgreSQL replication settings and privileges, Polaris OAuth and write permissions, temporary storage credentials for object uploads, and durable OLake checkpoints to resume from a saved WAL position. Local state offers higher I/O throughput but requires backup and failover planning; remote durable state eases recovery with higher latency. Commit frequency trades more frequent snapshots and metadata activity for lower recovery exposure, while longer windows reduce metadata operations but increase potential rework after a crash. The text recommends validating inserts, updates, deletes, and crash recovery in staging, and monitoring WAL lag, checkpoint age, uncommitted files, Polaris commit failures, and upload latency. Lost checkpoints can cause duplicates or gaps; exact-once behavior across these systems is described as difficult. Provider settings, connector-version behavior, credential lifetimes, and recovery procedures need verification in the deployment environment. OAuth secrets and temporary credentials should be kept out of logs and durable disk

### Source excerpt

Stream PostgreSQL CDC into Apache Iceberg with OLake Go and Apache Polaris, including REST catalog OAuth, vended credentials, resumable state, and validation. The post PostgreSQL CDC into Apache Iceberg with OLake Go and Apache Polaris appeared first on Dremio.

## Composable Parts Architecture

DevFeed: [Composable Parts Architecture](<https://devfeed.tech/articles/composable-parts-architecture-121430.md>)

Original publisher: [Read original article](<https://blog.devops.dev/composable-parts-architecture-b660caf40e8f?source=rss----33f8b2d9a328---4>)

Author: Scaibu

Published: 2026-11-06T09:47:16Z

Content type: article

Language: en

Sources: [DevOps.dev](<https://devfeed.tech/sources/devops-dev.md>)

Topics: [software-architecture](<https://devfeed.tech/topics/software-architecture.md>), [architecture-components](<https://devfeed.tech/topics/architecture-components.md>), [Dependency Inversion](<https://devfeed.tech/topics/dependency-inversion.md>), [Publish-subscribe pattern](<https://devfeed.tech/topics/pubsub.md>), [adapter pattern](<https://devfeed.tech/topics/adapter-pattern.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Integration testing](<https://devfeed.tech/topics/integration-testing.md>), [event-sourcing](<https://devfeed.tech/topics/event-sourcing.md>), [Deployment Strategies](<https://devfeed.tech/topics/deployment-strategies.md>), [rate-limiting](<https://devfeed.tech/topics/rate-limiting.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [clean-architecture](<https://devfeed.tech/tags/clean-architecture.md>), [code](<https://devfeed.tech/tags/code.md>), [components](<https://devfeed.tech/tags/components.md>), [connect](<https://devfeed.tech/tags/connect.md>), [contracts](<https://devfeed.tech/tags/contracts.md>), [crash](<https://devfeed.tech/tags/crash.md>), [data](<https://devfeed.tech/tags/data.md>), [data-ownership](<https://devfeed.tech/tags/data-ownership.md>), [deployment](<https://devfeed.tech/tags/deployment.md>), [design](<https://devfeed.tech/tags/design.md>), [durability](<https://devfeed.tech/tags/durability.md>), [enterprise-architecture](<https://devfeed.tech/tags/enterprise-architecture.md>), [event](<https://devfeed.tech/tags/event.md>), [event-driven-architecture](<https://devfeed.tech/tags/event-driven-architecture.md>), [execution](<https://devfeed.tech/tags/execution.md>), [features](<https://devfeed.tech/tags/features.md>), [independent](<https://devfeed.tech/tags/independent.md>), [integrate](<https://devfeed.tech/tags/integrate.md>), [internals](<https://devfeed.tech/tags/internals.md>), [logic](<https://devfeed.tech/tags/logic.md>), [messages](<https://devfeed.tech/tags/messages.md>), [parts](<https://devfeed.tech/tags/parts.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>)

### AI overview

The architecture aims to let parts change independently by having them depend on published, versioned contracts rather than one another's internals. Each part owns its data and exposes pure logic through ports and replaceable adapters; manifests let the platform validate and wire parts without hand-edited central registries. Events through a durable log are the default connection, while synchronous requests are reserved for cases needing an immediate answer and constrained to short call chains. An atomic outbox, idempotency keys, deduplication, checkpoints, deadlines, and retries make interruptions and duplicate delivery recoverable; consumers keep read-only data copies and reconcile them against their owner. The same contracts and host protocol support different runtimes, with adapters and test kits handling host-specific integration. The excerpt also describes contract versioning, graph validation, and domain-based deployment packing as ways to manage growth. These are architectural prescriptions; the supplied text does not establish implementation results.

### Source excerpt

How small, independent parts connect, share data, survive disconnects, integrate with any host, and grow to 1000+ features -- where adding or changing something touches one place, not a hundred.Contents The six rules Vocabulary The system at a glance Anatomy of a part Contracts Connecting parts Execution model inside a part Data ownership and sharing Integrating with any system Durability: connections that break safely Changing the system Scaling to 1000+ parts Platform components Enforcement Testing Adding a new part: checklist Anti-patterns Open decisions Introduction Most large systems do not fail because a single component is badly written. They fail because components know too much about each other. One service reads another service's tables "just this once"; a handler calls three other services in sequence because it was quicker than designing an event; a central routing file collects one line from every team until nobody can change it without a merge conflict. Each shortcut is harmless on its own. Together they produce a system in which adding a field means editing a hundred files, an outage in one corner takes down everything, and a dropped network connection corrupts data. This document describes a structure that prevents those outcomes by design rather than by discipline. It rests on two ideas: No part knows another part. Parts know contracts. A part is aware of its own logic and of the published, versioned contracts it uses. It never sees another part's code, storage, or deployment details. Because nothing depends on internals, internals can change freely. Every connection is assumed to break, and breaking must cost nothing. Networks drop, processes crash, and messages arrive twice or out of order. Instead of trying to prevent these failures, the structure makes each one harmless: nothing is lost, nothing happens twice, and nothing waits forever. Everything that follows is an elaboration of those two ideas, together with the tooling that keeps them true as

## Lantern: Finding Committable Transactions via Back-Propagation on DAGs

DevFeed: [Lantern: Finding Committable Transactions via Back-Propagation on DAGs](<https://devfeed.tech/articles/lantern-finding-committable-transactions-via-back-propagation-on-dags-121001.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2609.03315>)

Author: Denglong Li, Gerui Wang, Tian Guan, Mingchao Wan

Published: 2026-11-06T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Databases](<https://devfeed.tech/sources/arxiv-databases.md>), [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [Transactions](<https://devfeed.tech/topics/transactions.md>), [Blockchain](<https://devfeed.tech/topics/blockchain.md>)

Tags: [aria](<https://devfeed.tech/tags/aria.md>), [batch](<https://devfeed.tech/tags/batch.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [blockchain](<https://devfeed.tech/tags/blockchain.md>), [concurrency-control](<https://devfeed.tech/tags/concurrency-control.md>), [cs-db](<https://devfeed.tech/tags/cs-db.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-pf](<https://devfeed.tech/tags/cs-pf.md>), [dependency](<https://devfeed.tech/tags/dependency.md>), [dependency-graph](<https://devfeed.tech/tags/dependency-graph.md>), [evaluations](<https://devfeed.tech/tags/evaluations.md>), [execution](<https://devfeed.tech/tags/execution.md>), [high-performance](<https://devfeed.tech/tags/high-performance.md>), [integrate](<https://devfeed.tech/tags/integrate.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [protocols](<https://devfeed.tech/tags/protocols.md>), [transactions](<https://devfeed.tech/tags/transactions.md>)

### AI overview

Lantern is a deterministic concurrency control protocol designed to work without prior knowledge of transaction read-write sets. It commits zero-out-degree transactions in ascending order using an overwrite-permissive strategy, then applies back-propagation from sink to source vertices to identify more committable transactions. For read-modify-write intensive workloads, it also uses Conflict-Free Batch Selection. Integrated into ChainMaker, Lantern reportedly achieved up to 4.2x Aria's throughput on YCSB and SmallBank benchmarks and raised ChainMaker's execution-layer throughput by at least 2.2x.

### Source excerpt

arXiv:2609.03315v2 Announce Type: replace-cross Abstract: Existing concurrency control protocols either introduce nondeterminism, resulting in a serial execution-replay dependency between primary and replica nodes, or rely on impractical prior knowledge of transaction read-write sets. In this paper, we present Lantern, a deterministic concurrency control protocol tailored for high-performance transaction processing systems operating without prior knowledge. The key insight of Lantern is that all zero-out-degree transaction vertices in the local dependency graph can be safely committed in ascending order using an overwrite-permissive strategy. We further introduce a novel Back-Propagation mechanism that iteratively propagates dependency states from sink to source vertices to identify additional committable transactions. We also propose Conflict-Free Batch Selection (CFBS) for read-modify-write intensive scenarios. We integrate Lantern into the open-source blockchain platform ChainMaker. Extensive evaluations on YCSB and SmallBank benchmarks demonstrate that Lantern achieves up to a 4.2x throughput speedup over Aria and improves the throughput of ChainMaker's execution layer by at least 2.2x.

## Exactly-Once Publishing on Cloudflare D1 Without Transactions

DevFeed: [Exactly-Once Publishing on Cloudflare D1 Without Transactions](<https://devfeed.tech/articles/exactly-once-publishing-on-cloudflare-d1-without-transactions-119321.md>)

Original publisher: [Read original article](<https://hackernoon.com/exactly-once-publishing-on-cloudflare-d1-without-transactions?source=rss>)

Author: horushe

Published: 2026-11-05T15:44:50Z

Content type: article

Language: en

Sources: [HackerNoon](<https://devfeed.tech/sources/hackernoon.md>)

Topics: [database-consistency](<https://devfeed.tech/topics/database-consistency.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [race-condition](<https://devfeed.tech/topics/race-condition.md>), [cache-invalidation](<https://devfeed.tech/topics/cache-invalidation.md>), [Cloudflare](<https://devfeed.tech/topics/cloudflare.md>), [Cloudflare Workers](<https://devfeed.tech/topics/cloudflare-workers.md>), [Cache](<https://devfeed.tech/topics/cache.md>), [cache-control](<https://devfeed.tech/topics/cache-control.md>)

Tags: [atomic](<https://devfeed.tech/tags/atomic.md>), [batches](<https://devfeed.tech/tags/batches.md>), [cache](<https://devfeed.tech/tags/cache.md>), [cache-invalidation](<https://devfeed.tech/tags/cache-invalidation.md>), [cloudflare](<https://devfeed.tech/tags/cloudflare.md>), [cloudflare-d1](<https://devfeed.tech/tags/cloudflare-d1.md>), [cloudflare-workers](<https://devfeed.tech/tags/cloudflare-workers.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [condition](<https://devfeed.tech/tags/condition.md>), [content](<https://devfeed.tech/tags/content.md>), [d1](<https://devfeed.tech/tags/d1.md>), [distributed-locks](<https://devfeed.tech/tags/distributed-locks.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [exactly-once](<https://devfeed.tech/tags/exactly-once.md>), [exactly-once-processing](<https://devfeed.tech/tags/exactly-once-processing.md>), [fencing](<https://devfeed.tech/tags/fencing.md>), [fencing-tokens](<https://devfeed.tech/tags/fencing-tokens.md>), [learn-how-to](<https://devfeed.tech/tags/learn-how-to.md>), [publishing](<https://devfeed.tech/tags/publishing.md>), [race-conditions](<https://devfeed.tech/tags/race-conditions.md>), [revision](<https://devfeed.tech/tags/revision.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [sql](<https://devfeed.tech/tags/sql.md>), [transactions](<https://devfeed.tech/tags/transactions.md>)

### AI overview

The article's D1 publishing design combines expiring leases with fencing tokens and SQL guards inside every write. The final batch inserts the page only if lease and content checks still hold, then uses a random commit token to conditionally update the publication ledger and revision; a stale writer therefore makes no partial changes. Cache invalidation uses a global publication revision in cache keys instead of purges, with short lifetimes capped at scheduled visibility changes such as a post-midnight grace window. The tradeoff is one primary database read per cacheable request. A separate single-statement SQLite insert enforces unique sessions, dense slots and a 50,000-row puzzle limit. The article reports concurrent integration runs on Worker, D1 and R2 that published six pages once each and stored seven images once each.

### Source excerpt

Learn how to prevent duplicate writes in Cloudflare D1 using fencing tokens, guarded SQL batches, and revision-based cache invalidation.

## Optimizing Geo-replicated Deterministic Databases

DevFeed: [Optimizing Geo-replicated Deterministic Databases](<https://devfeed.tech/articles/optimizing-geo-replicated-deterministic-databases-118116.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.05882>)

Author: Yunhao Mao, Shiquan Zhang, Gengrui Zhang, Hans-Arno Jacobsen

Published: 2026-11-05T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Databases](<https://devfeed.tech/sources/arxiv-databases.md>)

Topics: [database-optimization](<https://devfeed.tech/topics/database-optimization.md>), [Replication](<https://devfeed.tech/topics/replication.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [strict-serializability](<https://devfeed.tech/topics/strict-serializability.md>), [consistency](<https://devfeed.tech/topics/consistency.md>), [performance-engineering](<https://devfeed.tech/topics/performance-engineering.md>), [crdt](<https://devfeed.tech/topics/crdt.md>), [locking](<https://devfeed.tech/topics/locking.md>)

Tags: [active-active](<https://devfeed.tech/tags/active-active.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [batch](<https://devfeed.tech/tags/batch.md>), [commit](<https://devfeed.tech/tags/commit.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [concurrency-control](<https://devfeed.tech/tags/concurrency-control.md>), [cs-db](<https://devfeed.tech/tags/cs-db.md>), [databases](<https://devfeed.tech/tags/databases.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [execution](<https://devfeed.tech/tags/execution.md>), [fast](<https://devfeed.tech/tags/fast.md>), [geo](<https://devfeed.tech/tags/geo.md>), [integration](<https://devfeed.tech/tags/integration.md>), [locking](<https://devfeed.tech/tags/locking.md>), [model](<https://devfeed.tech/tags/model.md>), [optimistic-concurrency](<https://devfeed.tech/tags/optimistic-concurrency.md>), [optimizations](<https://devfeed.tech/tags/optimizations.md>), [optimizing](<https://devfeed.tech/tags/optimizing.md>), [order](<https://devfeed.tech/tags/order.md>), [performance](<https://devfeed.tech/tags/performance.md>), [replication](<https://devfeed.tech/tags/replication.md>)

### AI overview

Deterministic concurrency control (DCC) can reduce coordination costs in geo-replicated databases by globally ordering transaction batches before execution. The paper analyzes DCC against two-phase locking and optimistic concurrency control, identifying conditions where DCC is advantageous, and presents Quirinus, which adds speculative execution, transaction reordering, CRDT integration, and fast-path commit. In the reported configuration, Quirinus achieves up to 6.2x TPC-C throughput versus Tiga even without those optimizations.

### Source excerpt

arXiv:2611.05882v1 Announce Type: new Abstract: In transactional databases, achieving active-active replication among geo-distributed replicas is challenging due to the high coordination cost in ensuring the serializability of concurrent cross-node transactions. Deterministic concurrency control (DCC) has emerged as a promising alternative: it establishes a global order for a batch of transactions before execution and thereby amortizes this coordination cost across the batch. To better understand the performance characteristics of DCC, we conduct a theoretical analysis of traditional two-phase locking and optimistic concurrency control to account for geo-replication and introduce a model for DCC. We compare the three paradigms and identify the conditions under which DCC is advantageous. Guided by the insights from this analysis, we then present Quirinus, a DCC-based geo-replicated database that optimizes transaction execution through speculative execution, transaction reordering, integration of conflict-free replicated data types (CRDTs), and fast-path commit. Even without these optimizations, Quirinus achieves up to 6.2x the TPC-C throughput of Tiga under our configuration.

## 5 Postgres Migrations That Work Fine in Dev and Lock Up Production

DevFeed: [5 Postgres Migrations That Work Fine in Dev and Lock Up Production](<https://devfeed.tech/articles/5-postgres-migrations-that-work-fine-in-dev-and-lock-up-production-117140.md>)

Original publisher: [Read original article](<https://thetshaped.dev/p/postgres-schema-migrations-lock-queue-zero-downtime-alter-table>)

Author: The T-Shaped Dev

Published: 2026-11-04T11:42:44Z

Content type: article

Language: en

Sources: [The T-Shaped Dev](<https://devfeed.tech/sources/the-t-shaped-dev.md>)

Topics: [Transactions](<https://devfeed.tech/topics/transactions.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [batch](<https://devfeed.tech/tags/batch.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [concurrently](<https://devfeed.tech/tags/concurrently.md>), [constraint](<https://devfeed.tech/tags/constraint.md>), [database](<https://devfeed.tech/tags/database.md>), [deploy](<https://devfeed.tech/tags/deploy.md>), [downtime](<https://devfeed.tech/tags/downtime.md>), [lock](<https://devfeed.tech/tags/lock.md>), [migrations](<https://devfeed.tech/tags/migrations.md>), [postgres](<https://devfeed.tech/tags/postgres.md>), [production](<https://devfeed.tech/tags/production.md>)

### AI overview

Postgres migrations can stall production through lock queues even when the migration itself is fast: a waiting `ACCESS EXCLUSIVE` lock makes later queries wait behind it. Set `lock_timeout`, then retry failed deploy attempts; the cap limits but does not eliminate request stalls. For large tables, add `NOT VALID` constraints and validate them in a later deploy, and build indexes with `CREATE INDEX CONCURRENTLY` outside a transaction. Concurrent index builds are slower, wait for older transactions, and can leave invalid indexes that must be checked and removed or rebuilt. Keep rolling deploys compatible with old app instances by expanding, backfilling, then contracting across deploys. Run backfills as re-runnable, primary-key-batched jobs with commits between batches. Since Postgres 11, constant defaults can be added instantly; volatile defaults rewrite the table, while `now()` assigns existing rows the migration transaction's timestamp. The text notes that MySQL has a similar lock queue but requires different fixes.

### Source excerpt

Each one looks harmless until the table is big. Why it locks, what your users see, and the safe version of each.

## Candidate and Active Configuration on IOS XR

DevFeed: [Candidate and Active Configuration on IOS XR](<https://devfeed.tech/articles/candidate-and-active-configuration-on-ios-xr-117165.md>)

Original publisher: [Read original article](<https://blog.ipspace.net/2026/11/candidate-active-configuration-iosxr/>)

Published: 2026-11-04T07:37:00Z

Content type: article

Language: en

Sources: [ipSpace](<https://devfeed.tech/sources/ipspace-net-blog-2.md>)

Topics: [Network Configuration](<https://devfeed.tech/topics/network-configuration.md>), [configuration](<https://devfeed.tech/topics/configuration.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>)

Tags: [all](<https://devfeed.tech/tags/all.md>), [automation](<https://devfeed.tech/tags/automation.md>), [band](<https://devfeed.tech/tags/band.md>), [candidate](<https://devfeed.tech/tags/candidate.md>), [changes](<https://devfeed.tech/tags/changes.md>), [command](<https://devfeed.tech/tags/command.md>), [commit](<https://devfeed.tech/tags/commit.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [copy](<https://devfeed.tech/tags/copy.md>), [days](<https://devfeed.tech/tags/days.md>), [device](<https://devfeed.tech/tags/device.md>), [devices](<https://devfeed.tech/tags/devices.md>), [disaster](<https://devfeed.tech/tags/disaster.md>), [introduced](<https://devfeed.tech/tags/introduced.md>), [ios](<https://devfeed.tech/tags/ios.md>), [juniper](<https://devfeed.tech/tags/juniper.md>), [make](<https://devfeed.tech/tags/make.md>), [making](<https://devfeed.tech/tags/making.md>), [memory](<https://devfeed.tech/tags/memory.md>), [more](<https://devfeed.tech/tags/more.md>), [xr](<https://devfeed.tech/tags/xr.md>)

### AI overview

Unlike snapshot-based candidate configurations, IOS XR starts configuration mode with an empty set of commands. You can inspect the pending commands with `show configuration`, preview the result of `commit` or `commit replace` with `show configuration merge` or `show configuration replace`, and view proposed differences with `show commit changes diff`. `commit` merges the entered commands; `commit replace` replaces the active configuration, so using it immediately after entering configuration mode can wipe that configuration. The excerpt describes these behaviors but does not cover safeguards or recovery.

### Source excerpt

Traditional network devices used a single (active or running) configuration, with a snapshot of it stored in permanent memory (startup configuration). The active configuration was modified with every configuration command, making it a perfect recipe for disaster in the days of in-band configuration1. The situation improved drastically when Juniper introduced the candidate configuration. You could make changes to a copy of the configuration, and then commit them as a single all-or-nothing transaction. While you could still cut yourself off from the device, at least it was harder to do with a single misordered command. Read more ...

## Boost+: Equitable, Incentive-Compatible Block Building

DevFeed: [Boost+: Equitable, Incentive-Compatible Block Building](<https://devfeed.tech/articles/boost-equitable-incentive-compatible-block-building-113980.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2602.04007>)

Author: Mengqian Zhang, Sen Yang, Kartik Nayak, Fan Zhang

Published: 2026-11-03T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>)

Topics: [genesis block](<https://devfeed.tech/topics/genesis-block.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [algorithms](<https://devfeed.tech/tags/algorithms.md>), [bidding](<https://devfeed.tech/tags/bidding.md>), [block](<https://devfeed.tech/tags/block.md>), [blockchain](<https://devfeed.tech/tags/blockchain.md>), [builder](<https://devfeed.tech/tags/builder.md>), [building](<https://devfeed.tech/tags/building.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [ethereum](<https://devfeed.tech/tags/ethereum.md>), [incentives](<https://devfeed.tech/tags/incentives.md>), [transactions](<https://devfeed.tech/tags/transactions.md>)

### AI overview

Boost+ aims to reduce centralization in Ethereum block building by pooling submitted order flows in an attested execution environment and giving participating block-building algorithms equal access. Its mechanism uses a baseline building algorithm and makes truthful bidding a dominant strategy for builders. For searchers, truthful reporting is dominant when the baseline algorithm dominates competing builders, and for conflict-free transactions even when builders may win. The abstract also claims that, for conflict-free transactions, a searcher's non-integration and truthful bidding dominate deviations even if integration with a builder is technically possible. The authors implement a baseline algorithm informed by empirical transaction analysis and evaluate it on historical data; the excerpt does not report the evaluation results.

### Source excerpt

arXiv:2602.04007v2 Announce Type: replace Abstract: Block space on the blockchain is scarce and must be allocated efficiently through block building. However, Ethereum's current block-building ecosystem, MEV-Boost, has become highly centralized due to integration, which distorts competition, reduces blockspace efficiency, and obscures MEV flow transparency. To improve equitability and economic efficiency in block building, we propose $\textsf{Boost+}$, a system that pools submitted order flows inside an attested execution environment and gives all participating block-building algorithms equal access to them. The core of $\textsf{Boost+}$ is the mechanism $M_{\textsf{Boost+}}$, built around a baseline block-building algorithm. $M_{\textsf{Boost+}}$ aligns incentives for both searchers (intermediaries that generate or route transactions) and builders: Truthful bidding is a dominant strategy for all builders. For searchers, truthful reporting is dominant whenever the baseline algorithm dominates competing builders, and it remains dominant for all conflict-free transactions, even when builders may win. We further show that even if a searcher can technically integrate with a builder, non-integration combined with truthful bidding still dominates any deviation for conflict-free transactions. We also implement a concrete baseline algorithm informed by empirical analysis of real-world transactions and evaluate its efficacy using historical data.

[Next page](<https://devfeed.tech/topics/transactions.md?cursor=WyIyMDI2LTExLTAzVDA1OjAwOjAwKzAwOjAwIiwgIjU4YWJmNjkwLTJhNTAtNGRkYi1iMGExLWNmMzFhMWI2YTYzNSJd>)