# acid

ACID is a set of properties--atomicity, consistency, isolation, and durability--that ensure data integrity in database transactions.

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

## 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.

## What is a transactional database? Definition and uses | Blog | Fivetran

DevFeed: [What is a transactional database? Definition and uses | Blog | Fivetran](<https://devfeed.tech/articles/what-is-a-transactional-database-definition-and-uses-blog-fivetran-140211.md>)

Original publisher: [Read original article](<https://wf.fivetran.com/blog/databases-demystified-analytical-vs-transactional>)

Author: Michael Kaminsky

Published: 2026-11-18T03:07:10Z

Content type: article

Language: en

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

Topics: [Transactions](<https://devfeed.tech/topics/transactions.md>), [Database](<https://devfeed.tech/topics/database.md>), [acid](<https://devfeed.tech/topics/acid.md>), [database-consistency](<https://devfeed.tech/topics/database-consistency.md>), [rdbms](<https://devfeed.tech/topics/rdbms.md>), [sql-database](<https://devfeed.tech/topics/sql-database.md>), [SQL](<https://devfeed.tech/topics/sql.md>)

Tags: [acid](<https://devfeed.tech/tags/acid.md>), [analytics](<https://devfeed.tech/tags/analytics.md>), [application](<https://devfeed.tech/tags/application.md>), [applications](<https://devfeed.tech/tags/applications.md>), [bank](<https://devfeed.tech/tags/bank.md>), [banks](<https://devfeed.tech/tags/banks.md>), [benefit](<https://devfeed.tech/tags/benefit.md>), [benefits](<https://devfeed.tech/tags/benefits.md>), [bi](<https://devfeed.tech/tags/bi.md>), [blog](<https://devfeed.tech/tags/blog.md>), [business](<https://devfeed.tech/tags/business.md>), [business-intelligence](<https://devfeed.tech/tags/business-intelligence.md>), [cases](<https://devfeed.tech/tags/cases.md>), [data](<https://devfeed.tech/tags/data.md>), [database](<https://devfeed.tech/tags/database.md>), [definition](<https://devfeed.tech/tags/definition.md>), [fivetran](<https://devfeed.tech/tags/fivetran.md>), [use-cases](<https://devfeed.tech/tags/use-cases.md>), [uses](<https://devfeed.tech/tags/uses.md>), [what-is](<https://devfeed.tech/tags/what-is.md>)

### AI overview

Transactional databases handle day-to-day operations by processing individual records through transactions that succeed or fail as a unit. ACID properties provide the core guarantees: atomicity rolls back incomplete operations, consistency enforces database rules, isolation controls interference between concurrent transactions, and durability preserves committed changes in persistent storage. These systems support fast reads and writes, record-level updates, and operational tasks such as payments, reservations, inventory, and patient records. Relational databases commonly provide ACID guarantees with structured tables but fixed schemas; NoSQL systems offer flexible data models and scalability, though consistency guarantees vary. Transactional workloads are optimized for rapid individual changes, while analytical databases better suit complex reporting across large datasets. The text notes that many businesses use both and that integrating them can be an engineering challenge.

### Source excerpt

Learn what a transactional database is, how it manages transactional data, and how it compares to other database technologies and use cases.

## ACID Clearly Explained

DevFeed: [ACID Clearly Explained](<https://devfeed.tech/articles/acid-clearly-explained-109234.md>)

Original publisher: [Read original article](<https://blog.levelupcoding.com/p/acid-clearly-explained>)

Author: Nikki Siapno

Published: 2026-10-30T12:38:33Z

Content type: article

Language: en

Sources: [Level Up Coding System Design Newsletter](<https://devfeed.tech/sources/level-up-coding-system-design-newsletter.md>)

Topics: [acid](<https://devfeed.tech/topics/acid.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [database-consistency](<https://devfeed.tech/topics/database-consistency.md>)

Tags: [account-management](<https://devfeed.tech/tags/account-management.md>), [acid](<https://devfeed.tech/tags/acid.md>), [availability](<https://devfeed.tech/tags/availability.md>), [blocking](<https://devfeed.tech/tags/blocking.md>), [booking](<https://devfeed.tech/tags/booking.md>), [business-logic](<https://devfeed.tech/tags/business-logic.md>), [commit](<https://devfeed.tech/tags/commit.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [concurrency-control](<https://devfeed.tech/tags/concurrency-control.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [constraint](<https://devfeed.tech/tags/constraint.md>), [crash-recovery](<https://devfeed.tech/tags/crash-recovery.md>), [database](<https://devfeed.tech/tags/database.md>), [databases](<https://devfeed.tech/tags/databases.md>), [distributed-databases](<https://devfeed.tech/tags/distributed-databases.md>), [durability](<https://devfeed.tech/tags/durability.md>), [failure](<https://devfeed.tech/tags/failure.md>), [foreign-keys](<https://devfeed.tech/tags/foreign-keys.md>), [guarantees](<https://devfeed.tech/tags/guarantees.md>)

### AI overview

ACID addresses four distinct transaction failure modes: atomicity prevents partial completion through commit or rollback; consistency preserves database constraints, though rules held only in application code must still be enforced there; isolation controls interference among concurrent transactions, with stronger levels generally requiring more coordination; and durability preserves committed changes across failures, often using a write-ahead log. Databases combine transaction managers, logs, locks, MVCC, and constraints differently. The article highlights ACID for payments, orders, inventory, and bookings, while noting that coordination can raise latency and reduce throughput, so the needed guarantees depend on the cost of incorrect or lost updates.

### Source excerpt

Four guarantees. Four different failure modes. Here's how they work.

## Replacing Transactional MSMQ with RabbitMQ Without Losing Consistency

DevFeed: [Replacing Transactional MSMQ with RabbitMQ Without Losing Consistency](<https://devfeed.tech/articles/replacing-transactional-msmq-with-rabbitmq-without-losing-consistency-97413.md>)

Original publisher: [Read original article](<https://hackernoon.com/replacing-transactional-msmq-with-rabbitmq-without-losing-consistency?source=rss>)

Author: Ilnur Yusupov

Published: 2026-10-23T08:31:42Z

Content type: article

Language: en

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

Topics: [RabbitMQ](<https://devfeed.tech/topics/rabbitmq.md>), [Messaging](<https://devfeed.tech/topics/messaging.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [consistency](<https://devfeed.tech/topics/consistency.md>), [acid](<https://devfeed.tech/topics/acid.md>), [schema-evolution](<https://devfeed.tech/topics/schema-evolution.md>)

Tags: [consistency](<https://devfeed.tech/tags/consistency.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [msmq](<https://devfeed.tech/tags/msmq.md>), [msmq-to-rabbitmq-migration](<https://devfeed.tech/tags/msmq-to-rabbitmq-migration.md>), [net](<https://devfeed.tech/tags/net.md>), [net-framework](<https://devfeed.tech/tags/net-framework.md>), [outbox](<https://devfeed.tech/tags/outbox.md>), [outbox-pattern](<https://devfeed.tech/tags/outbox-pattern.md>), [rabbitmq](<https://devfeed.tech/tags/rabbitmq.md>), [sql-server-transactions](<https://devfeed.tech/tags/sql-server-transactions.md>)

### AI overview

A direct MSMQ-to-RabbitMQ swap loses the atomicity that System.Transactions and MSDTC can provide across SQL Server and transactional MSMQ. Publishing before the SQL commit can expose an event for rolled-back data; publishing afterward can leave committed data without an event. The outbox addresses this dual-write gap by recording the business change and outgoing message in one database transaction, then dispatching to RabbitMQ asynchronously with publisher confirms and retries. A crash after broker confirmation but before marking the outbox row can cause duplicate publication, so consumers need idempotent processing, such as storing MessageId with business updates in one transaction. This replaces coordinated distributed transactions with eventual consistency and at-least-once delivery. The article also outlines operational needs such as concurrent row claiming, backoff, ordering, poison-message handling, monitoring, and cleanup, and recommends isolating messaging changes from runtime migration.

### Source excerpt

Learn why replacing transactional MSMQ with RabbitMQ changes consistency guarantees and how the outbox pattern helps preserve reliable messaging. TL;DR: Repla

## The saga pattern is compensating transactions with better marketing

DevFeed: [The saga pattern is compensating transactions with better marketing](<https://devfeed.tech/articles/the-saga-pattern-is-compensating-transactions-with-better-marketing-94471.md>)

Original publisher: [Read original article](<https://ankit-rana.com/logs/68-sagas-are-compensating-transactions/>)

Author: hello@ankit-rana.com

Published: 2026-10-22T00:00:00Z

Content type: article

Language: en

Sources: [Ankit Rana | Mechanical Sympathy](<https://devfeed.tech/sources/ankit-rana-mechanical-sympathy.md>)

Topics: [Transactions](<https://devfeed.tech/topics/transactions.md>), [acid](<https://devfeed.tech/topics/acid.md>), [Publish-subscribe pattern](<https://devfeed.tech/topics/pubsub.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [atomic](<https://devfeed.tech/tags/atomic.md>), [availability](<https://devfeed.tech/tags/availability.md>), [compensating-transactions](<https://devfeed.tech/tags/compensating-transactions.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [distributed-transactions](<https://devfeed.tech/tags/distributed-transactions.md>), [email](<https://devfeed.tech/tags/email.md>), [isolation](<https://devfeed.tech/tags/isolation.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [observable](<https://devfeed.tech/tags/observable.md>), [payment](<https://devfeed.tech/tags/payment.md>), [reliability](<https://devfeed.tech/tags/reliability.md>), [rollback](<https://devfeed.tech/tags/rollback.md>), [saga](<https://devfeed.tech/tags/saga.md>), [transactions](<https://devfeed.tech/tags/transactions.md>)

### AI overview

A saga trades a single transaction's isolation for independently committed service steps: intermediate states are visible, and failures require new compensating actions rather than rollback. Those actions can fail too, so the article calls for idempotent steps and compensations, retries, timeouts, durable and queryable saga state, and human escalation when compensation cannot succeed. It recommends ordering reversible work first and irreversible actions, such as sending confirmation, last; where possible, reserve resources before finalizing them. Choreography avoids a coordinator but leaves workflow and progress scattered across services. Orchestration centralizes sequencing, state tracking, recovery, and compensation, at the cost of a coordination component. The pattern adds substantial failure-path complexity; the author advises using it when service boundaries make a local transaction impossible, and notes that visible intermediate states must be acceptable to the product.

### Source excerpt

A saga replaces one atomic transaction with a sequence of local transactions, each of which commits and becomes visible immediately, so there is no isolation and intermediate states are observable. When a later step fails, earlier ones are undone by running compensating actions, which are forward operations with their own failure modes rather than a rollback. The difficulty is not the mechanism but the steps that cannot be compensated, such as an email already sent or a payment already captured, which have to be designed around rather than reversed.

## How to Architect an On-Premises Data Lakehouse

DevFeed: [How to Architect an On-Premises Data Lakehouse](<https://devfeed.tech/articles/how-to-architect-an-on-premises-data-lakehouse-87813.md>)

Original publisher: [Read original article](<https://www.starburst.io/blog/how-to-architect-an-on-premises-data-lakehouse>)

Published: 2026-10-15T08:00:34Z

Content type: article

Language: en

Sources: [Starburst Data](<https://devfeed.tech/sources/starburst-data.md>)

Topics: [data lake](<https://devfeed.tech/topics/data-lake.md>), [database-optimization](<https://devfeed.tech/topics/database-optimization.md>), [acid](<https://devfeed.tech/topics/acid.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [Cache](<https://devfeed.tech/topics/cache.md>), [control-plane](<https://devfeed.tech/topics/control-plane.md>), [parquet](<https://devfeed.tech/topics/parquet.md>), [AI Infrastructure](<https://devfeed.tech/topics/ai-infrastructure.md>), [AI-Ready Data](<https://devfeed.tech/topics/ai-ready-data.md>)

Tags: [access-control](<https://devfeed.tech/tags/access-control.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-workloads](<https://devfeed.tech/tags/ai-workloads.md>), [air-gapped](<https://devfeed.tech/tags/air-gapped.md>), [amazon-s3](<https://devfeed.tech/tags/amazon-s3.md>), [analytics](<https://devfeed.tech/tags/analytics.md>), [apache-iceberg](<https://devfeed.tech/tags/apache-iceberg.md>), [apache-iceberg-tables](<https://devfeed.tech/tags/apache-iceberg-tables.md>), [architect](<https://devfeed.tech/tags/architect.md>), [audit](<https://devfeed.tech/tags/audit.md>), [availability](<https://devfeed.tech/tags/availability.md>), [bandwidth](<https://devfeed.tech/tags/bandwidth.md>), [batch](<https://devfeed.tech/tags/batch.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [bi](<https://devfeed.tech/tags/bi.md>), [big-bang](<https://devfeed.tech/tags/big-bang.md>), [build](<https://devfeed.tech/tags/build.md>), [built-in](<https://devfeed.tech/tags/built-in.md>), [data-lakehouse](<https://devfeed.tech/tags/data-lakehouse.md>), [lakehouse](<https://devfeed.tech/tags/lakehouse.md>)

### AI overview

An on-premises lakehouse can serve sovereignty, regulatory, latency, or egress-cost needs using S3-compatible object storage, Apache Iceberg, and Trino, while separating storage from compute. Plan capacity, durability, network bandwidth, and the Iceberg catalog early; compatibility varies by provider: open-source Trino is tested with Amazon S3 and MinIO, while Starburst Enterprise documents its supported stores. The article recommends starting federation-first, then materializing frequently used paths into Iceberg, and building access controls, audit, and governed data products in from day one. Migrate from Hadoop in stages: replace Hive or Impala with Trino while HDFS remains, write new data to Iceberg, selectively convert Hive tables, then retire legacy components. Starburst Enterprise multi-cluster availability features require Elite and were in public preview in 480-e; running queries may fail during coordinator failover, so the article advises testing recovery plans that do not depend on those features.

### Source excerpt

An on-premises data lakehouse brings lakehouse capabilities into data centers you own or lease. It ...

## Let's build a database!

DevFeed: [Let's build a database!](<https://devfeed.tech/articles/let-s-build-a-database-113332.md>)

Original publisher: [Read original article](<https://stack.convex.dev/lets-build-a-database>)

Author: Stack

Published: 2026-10-09T15:00:37Z

Content type: tutorial

Language: en

Sources: [Stack](<https://devfeed.tech/sources/stack.md>)

Topics: [Database](<https://devfeed.tech/topics/database.md>), [SQLite](<https://devfeed.tech/topics/sqlite.md>), [transaction-log](<https://devfeed.tech/topics/transaction-log.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [acid](<https://devfeed.tech/topics/acid.md>), [database-consistency](<https://devfeed.tech/topics/database-consistency.md>), [Heroku Postgres](<https://devfeed.tech/topics/heroku-postgres.md>)

Tags: [build](<https://devfeed.tech/tags/build.md>), [convex](<https://devfeed.tech/tags/convex.md>), [database](<https://devfeed.tech/tags/database.md>), [file](<https://devfeed.tech/tags/file.md>), [fundamentals](<https://devfeed.tech/tags/fundamentals.md>), [json](<https://devfeed.tech/tags/json.md>), [postgres](<https://devfeed.tech/tags/postgres.md>), [sqlite](<https://devfeed.tech/tags/sqlite.md>), [wrapper](<https://devfeed.tech/tags/wrapper.md>)

### AI overview

Convex's SQLite or Postgres layer stores bytes; the article attributes its transactional and reactive behavior to Convex's own backend. It builds a model from an append-only transaction log, a committer that validates read sets and retries conflicts, timestamps and versioned indexes for snapshot reads, and subscriptions that rerun queries after relevant commits. Mutations must be deterministic and side effect free so retries are safe; actions handle external effects, while a scheduler can enqueue them atomically with a successful mutation. Inspection of a local SQLite deployment shows document versions stored as timestamped rows linked to prior versions, with indexes also persisted in tables. The article presents this as an explanatory model and notes that other Convex features are outside its scope.

### Source excerpt

Is Convex just a Postgres wrapper? To answer that we build a database from scratch with the same properties as Convex, starting from a single JSON file, then crack open the SQLite file Convex uses to see what it's actually doing.

## Database for AI Agents: 5 Evaluation Criteria

DevFeed: [Database for AI Agents: 5 Evaluation Criteria](<https://devfeed.tech/articles/database-for-ai-agents-5-evaluation-criteria-42692.md>)

Original publisher: [Read original article](<https://www.databricks.com/blog/database-for-ai-agents>)

Author: Databricks Staff

Published: 2026-09-17T17:27:40Z

Content type: article

Language: en

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

Topics: [Database](<https://devfeed.tech/topics/database.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Scalability](<https://devfeed.tech/topics/scalability.md>), [Serverless](<https://devfeed.tech/topics/serverless.md>), [hybrid-search](<https://devfeed.tech/topics/hybrid-search.md>), [acid](<https://devfeed.tech/topics/acid.md>), [synthetic-data](<https://devfeed.tech/topics/synthetic-data.md>), [systems](<https://devfeed.tech/topics/systems.md>)

Tags: [acid](<https://devfeed.tech/tags/acid.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [data-plus-ai-foundations](<https://devfeed.tech/tags/data-plus-ai-foundations.md>), [database](<https://devfeed.tech/tags/database.md>), [databases](<https://devfeed.tech/tags/databases.md>), [developers](<https://devfeed.tech/tags/developers.md>), [hybrid-search](<https://devfeed.tech/tags/hybrid-search.md>), [scaling](<https://devfeed.tech/tags/scaling.md>), [serverless](<https://devfeed.tech/tags/serverless.md>), [synthetic-data](<https://devfeed.tech/tags/synthetic-data.md>)

### AI overview

The article presents five criteria for evaluating databases that support AI agents in production: branch isolation, serverless scaling, hybrid search, ACID guarantees, and unified platform access. It explains why agent workloads require persistent state, memory, tool results, repeated reads and writes, concurrent activity, and access to current operational data.

### Source excerpt

The five criteria for evaluating a database for AI agents are branch isolation, serverless...

## Data Lakehouse: What It Is, Benefits & Architecture

DevFeed: [Data Lakehouse: What It Is, Benefits & Architecture](<https://devfeed.tech/articles/data-lakehouse-what-it-is-benefits-architecture-136823.md>)

Original publisher: [Read original article](<https://wf.fivetran.com/blog/what-is-a-data-lakehouse>)

Author: Fivetran

Published: 2026-07-28T16:58:07Z

Content type: article

Language: en

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

Topics: [Analytics Pipeline](<https://devfeed.tech/topics/analytics-pipeline.md>), [data-engineering](<https://devfeed.tech/topics/data-engineering.md>), [data lake](<https://devfeed.tech/topics/data-lake.md>), [deltalake](<https://devfeed.tech/topics/deltalake.md>), [streaming data analytics](<https://devfeed.tech/topics/streaming-data-analytics.md>), [big-data](<https://devfeed.tech/topics/big-data.md>), [acid](<https://devfeed.tech/topics/acid.md>), [Machine learning](<https://devfeed.tech/topics/machine-learning.md>), [etl](<https://devfeed.tech/topics/etl.md>), [data](<https://devfeed.tech/topics/data.md>), [elt](<https://devfeed.tech/topics/elt.md>), [databricks](<https://devfeed.tech/topics/databricks.md>)

Tags: [acid](<https://devfeed.tech/tags/acid.md>), [addition](<https://devfeed.tech/tags/addition.md>), [admin](<https://devfeed.tech/tags/admin.md>), [advanced](<https://devfeed.tech/tags/advanced.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-and-ml](<https://devfeed.tech/tags/ai-and-ml.md>), [all](<https://devfeed.tech/tags/all.md>), [allows](<https://devfeed.tech/tags/allows.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [analysts](<https://devfeed.tech/tags/analysts.md>), [analytics](<https://devfeed.tech/tags/analytics.md>), [analyze](<https://devfeed.tech/tags/analyze.md>), [api](<https://devfeed.tech/tags/api.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [challenges](<https://devfeed.tech/tags/challenges.md>), [data](<https://devfeed.tech/tags/data.md>), [data-lakehouse](<https://devfeed.tech/tags/data-lakehouse.md>), [data-lakes](<https://devfeed.tech/tags/data-lakes.md>), [lakehouse](<https://devfeed.tech/tags/lakehouse.md>), [modern](<https://devfeed.tech/tags/modern.md>)

### AI overview

A data lakehouse combines low-cost, scalable object storage for structured and unstructured data with warehouse capabilities such as schema enforcement, ACID transactions, governance, and SQL analytics. Its layers cover ingestion, storage, metadata, querying, and downstream consumption; decoupling storage from compute allows multiple query engines to use the same data. Compared with a warehouse, it accommodates raw and varied data more flexibly; compared with a lake, it adds controls for consistency and governance. The article presents streaming analytics, data science, and enterprise BI as use cases, and cites reduced duplicated storage and data movement as potential benefits. Challenges include architectural complexity, choosing components across layers, and the need for new skills. Fivetran is described as an ingestion option, with automated connectors and managed ELT pipelines.

### Source excerpt

Learn what a data lakehouse is, its core architecture, and how it compares to data lakes and data warehouses to solve modern data challenges.

## RoachFest London 2026 Preview: AI Agents and an Astronaut Walk Into a Database Conference

DevFeed: [RoachFest London 2026 Preview: AI Agents and an Astronaut Walk Into a Database Conference](<https://devfeed.tech/articles/roachfest-london-2026-preview-ai-agents-and-an-astronaut-walk-into-a-database-conference-23808.md>)

Original publisher: [Read original article](<https://cockroachlabs.com/blog/roachfest-london-2026-preview>)

Author: Rob Reid

Published: 2026-06-09T00:00:00Z

Content type: news

Language: en

Sources: [Cockroach Labs](<https://devfeed.tech/sources/cockroach-labs.md>)

Topics: [CockroachDB](<https://devfeed.tech/topics/cockroachdb.md>), [Database](<https://devfeed.tech/topics/database.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [acid](<https://devfeed.tech/topics/acid.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [astronaut](<https://devfeed.tech/tags/astronaut.md>), [conference](<https://devfeed.tech/tags/conference.md>), [database](<https://devfeed.tech/tags/database.md>), [london](<https://devfeed.tech/tags/london.md>), [preview](<https://devfeed.tech/tags/preview.md>)

### AI overview

RoachFest London 2026 is scheduled for June 25 at Convene, with a program focused on resilience, distributed databases, and adapting to AI. The announced sessions include CockroachDB CEO Spencer Kimball on database architecture as agentic AI changes scale; Form3's cloud-agnostic active/active/active payment platform across AWS, GCP, and Azure, whose disaster recovery is tested by taking a provider offline for 24 hours in production; and a panel on AI-agent state tradeoffs including semantic retrieval and SQL-native memory. Workshops cover distributed SQL, Raft, survivability and multi-region strategies, plus transactional vector search and RAG on CockroachDB. The event also features product roadmap topics such as BYOC and AI-powered migration, partner demos, and astronaut Tim Peake on preparation and resilience.

### Source excerpt

Cockroach Labs has been hosting our annual database conference since 2022, and I'm honored to be MCing RoachFest London for the third year running.

## 8 AI Use Cases That Depend on Database Resilience

DevFeed: [8 AI Use Cases That Depend on Database Resilience](<https://devfeed.tech/articles/8-ai-use-cases-that-depend-on-database-resilience-23748.md>)

Original publisher: [Read original article](<https://cockroachlabs.com/blog/ai-use-cases-database-resilience>)

Author: David Weiss

Published: 2026-04-30T00:00:00Z

Content type: article

Language: en

Sources: [Cockroach Labs](<https://devfeed.tech/sources/cockroach-labs.md>)

Topics: [Resilience](<https://devfeed.tech/topics/resilience.md>), [AI Integration Strategies](<https://devfeed.tech/topics/ai-integration-strategies.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [data-engineering](<https://devfeed.tech/topics/data-engineering.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [database-consistency](<https://devfeed.tech/topics/database-consistency.md>), [acid](<https://devfeed.tech/topics/acid.md>), [Persistence](<https://devfeed.tech/topics/persistence.md>), [AI Context Management](<https://devfeed.tech/topics/ai-context-management.md>), [workflow automation](<https://devfeed.tech/topics/workflow-automation.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [acid](<https://devfeed.tech/tags/acid.md>), [actions](<https://devfeed.tech/tags/actions.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-systems](<https://devfeed.tech/tags/ai-systems.md>), [ai-use](<https://devfeed.tech/tags/ai-use.md>), [business](<https://devfeed.tech/tags/business.md>), [cases](<https://devfeed.tech/tags/cases.md>), [changes](<https://devfeed.tech/tags/changes.md>), [core](<https://devfeed.tech/tags/core.md>), [database](<https://devfeed.tech/tags/database.md>), [embedded](<https://devfeed.tech/tags/embedded.md>), [model](<https://devfeed.tech/tags/model.md>), [resilience](<https://devfeed.tech/tags/resilience.md>), [state](<https://devfeed.tech/tags/state.md>), [systems](<https://devfeed.tech/tags/systems.md>), [turning](<https://devfeed.tech/tags/turning.md>), [use-cases](<https://devfeed.tech/tags/use-cases.md>), [with](<https://devfeed.tech/tags/with.md>), [workflows](<https://devfeed.tech/tags/workflows.md>)

### AI overview

AI workloads make database failures consequential because model outputs become durable changes to business state. The text identifies use cases including real-time decisioning, global personalization, IoT, transactional workflows, gaming, multi-region pipelines, agent execution state, and persistent memory. Their needs include strong consistency, durable transactions, low-latency global access, resilient writes, and recovery under failure; the tradeoffs include latency, locality, and compliance. It describes distributed SQL as a way to combine transactional guarantees with replication across nodes and regions, reducing manual sharding and failover work. CockroachDB is presented as one implementation, with consensus-based replication, PostgreSQL wire compatibility, data locality controls, online schema changes, and support for vector data and agent state. These are architectural claims in the supplied excerpt, not comparative performance evidence.

### Source excerpt

As AI systems become embedded in core business workflows, they increasingly interact directly with systems of record, turning model outputs into durable state changes.

## I don't care about your database benchmarks (and neither should you)

DevFeed: [I don't care about your database benchmarks (and neither should you)](<https://devfeed.tech/articles/i-don-t-care-about-your-database-benchmarks-and-neither-should-you-81418.md>)

Original publisher: [Read original article](<https://stack.convex.dev/on-competitive-benchmarks>)

Author: Stack

Published: 2026-02-25T16:50:00Z

Content type: opinion

Language: en

Sources: [Stack](<https://devfeed.tech/sources/stack.md>)

Topics: [Database](<https://devfeed.tech/topics/database.md>), [Rockset](<https://devfeed.tech/topics/rockset.md>), [consistency](<https://devfeed.tech/topics/consistency.md>), [acid](<https://devfeed.tech/topics/acid.md>), [transaction-log](<https://devfeed.tech/topics/transaction-log.md>), [read-replica](<https://devfeed.tech/topics/read-replica.md>), [Internets of interest](<https://devfeed.tech/topics/internets-of-interest.md>)

Tags: [acid](<https://devfeed.tech/tags/acid.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [buffer](<https://devfeed.tech/tags/buffer.md>), [caching](<https://devfeed.tech/tags/caching.md>), [class](<https://devfeed.tech/tags/class.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [cost](<https://devfeed.tech/tags/cost.md>), [cpus](<https://devfeed.tech/tags/cpus.md>), [crash](<https://devfeed.tech/tags/crash.md>), [customer](<https://devfeed.tech/tags/customer.md>), [data](<https://devfeed.tech/tags/data.md>), [database](<https://devfeed.tech/tags/database.md>), [datasets](<https://devfeed.tech/tags/datasets.md>), [development](<https://devfeed.tech/tags/development.md>), [durability](<https://devfeed.tech/tags/durability.md>), [failure](<https://devfeed.tech/tags/failure.md>), [fsync](<https://devfeed.tech/tags/fsync.md>), [perspectives](<https://devfeed.tech/tags/perspectives.md>)

### AI overview

Convex argues that database benchmark charts often compare systems with different durability, consistency, workload, and configuration assumptions, making headline performance rankings misleading. It recommends learning from real customer workloads and reporting representative latency, cost, and performance trends to help customers evaluate capacity and scaling.

### Source excerpt

Consider this our declaration of permanent disengagement from "bar chart wars." It's good dev marketing, but it's a waste of time.

## Two Betting Platforms, One Lesson: The Database Matters

DevFeed: [Two Betting Platforms, One Lesson: The Database Matters](<https://devfeed.tech/articles/two-betting-platforms-one-lesson-the-database-matters-23755.md>)

Original publisher: [Read original article](<https://cockroachlabs.com/blog/betting-platforms-database-matters>)

Author: Becca Weng

Published: 2026-02-24T00:00:00Z

Content type: article

Language: en

Sources: [Cockroach Labs](<https://devfeed.tech/sources/cockroach-labs.md>)

Topics: [CockroachDB](<https://devfeed.tech/topics/cockroachdb.md>), [Database](<https://devfeed.tech/topics/database.md>), [database-scalability](<https://devfeed.tech/topics/database-scalability.md>), [database-consistency](<https://devfeed.tech/topics/database-consistency.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [acid](<https://devfeed.tech/topics/acid.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [betting](<https://devfeed.tech/tags/betting.md>), [database](<https://devfeed.tech/tags/database.md>), [events](<https://devfeed.tech/tags/events.md>), [gaming](<https://devfeed.tech/tags/gaming.md>), [growth](<https://devfeed.tech/tags/growth.md>), [hit](<https://devfeed.tech/tags/hit.md>), [major](<https://devfeed.tech/tags/major.md>), [matters](<https://devfeed.tech/tags/matters.md>), [one](<https://devfeed.tech/tags/one.md>), [platform](<https://devfeed.tech/tags/platform.md>), [platforms](<https://devfeed.tech/tags/platforms.md>), [questions](<https://devfeed.tech/tags/questions.md>), [real-time](<https://devfeed.tech/tags/real-time.md>), [regulators](<https://devfeed.tech/tags/regulators.md>), [revenue](<https://devfeed.tech/tags/revenue.md>), [time](<https://devfeed.tech/tags/time.md>), [traffic](<https://devfeed.tech/tags/traffic.md>), [transactions](<https://devfeed.tech/tags/transactions.md>), [trust](<https://devfeed.tech/tags/trust.md>)

### AI overview

At RoachFest 2025, betting operators Newton and Kaizen Gaming described using CockroachDB to handle growth and traffic spikes while keeping real-money transactions consistent and services available. Newton, expanding across Europe and Africa, cited multi-region operation, replication, automatic load balancing, and PostgreSQL compatibility as reasons for choosing it; the article says the platform supports peak-event traffic without downtime. Kaizen, with more than 13 million active users in 19 countries, said 41% of its examined incidents were database-related. In performance testing, it scaled from hundreds of thousands to over 800,000 inserts per minute by adding nodes, without re-architecting. It also cited ACID transactions, automatic rebalancing, and maintenance without taking systems offline. These are company-reported experiences; the excerpt does not provide independent comparisons or test methodology.

### Source excerpt

In betting and gaming, growth is rarely gradual. Traffic spikes around major sporting events. Millions of real-time transactions hit your platform at once, and every one of them has to be correct. When the database falters, the consequences aren't abstract. Revenue stops. Players lose trust. Regulators start asking questions.

## ACID Transactions Explained: Properties, Examples, and Real-Time Applications

DevFeed: [ACID Transactions Explained: Properties, Examples, and Real-Time Applications](<https://devfeed.tech/articles/acid-transactions-explained-properties-examples-and-real-time-applications-81963.md>)

Original publisher: [Read original article](<https://estuary.dev/blog/acid-transactions>)

Author: Team Estuary

Published: 2025-08-14T07:15:50Z

Content type: tutorial

Language: en

Sources: [Estuary](<https://devfeed.tech/sources/estuary.md>)

Topics: [acid](<https://devfeed.tech/topics/acid.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [database-consistency](<https://devfeed.tech/topics/database-consistency.md>), [strict-serializability](<https://devfeed.tech/topics/strict-serializability.md>), [streaming data analytics](<https://devfeed.tech/topics/streaming-data-analytics.md>), [mobile devops](<https://devfeed.tech/topics/mobile-devops.md>)

Tags: [acid](<https://devfeed.tech/tags/acid.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [concurrency-control](<https://devfeed.tech/tags/concurrency-control.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [data](<https://devfeed.tech/tags/data.md>), [data-integrity](<https://devfeed.tech/tags/data-integrity.md>), [real-time](<https://devfeed.tech/tags/real-time.md>), [transactions](<https://devfeed.tech/tags/transactions.md>)

### AI overview

The article explains the ACID properties--atomicity, consistency, isolation, and durability--and how databases implement them through mechanisms such as transaction logs, constraints, locking, and MVCC. It also compares ACID with BASE and describes how Estuary Flow applies ACID-like guarantees to distributed streaming pipelines through exactly-once delivery, schema enforcement, transactional materializations, and recovery logs.

### Source excerpt

Learn what ACID transactions are, how their properties ensure data integrity, and why they matter in real-time systems. Includes examples, pros and cons.

## Snapshot Isolation vs Serializability

DevFeed: [Snapshot Isolation vs Serializability](<https://devfeed.tech/articles/snapshot-isolation-vs-serializability-12567.md>)

Original publisher: [Read original article](<http://brooker.co.za/blog/2024/12/17/occ-and-isolation.html>)

Author: Marc Brooker

Published: 2024-12-17T00:00:00Z

Content type: article

Language: en

Sources: [Marc Brooker's](<https://devfeed.tech/sources/marc-brooker-s-blog.md>)

Topics: [Transactions](<https://devfeed.tech/topics/transactions.md>), [Database](<https://devfeed.tech/topics/database.md>), [DSQL](<https://devfeed.tech/topics/dsql.md>), [acid](<https://devfeed.tech/topics/acid.md>)

Tags: [dsql](<https://devfeed.tech/tags/dsql.md>), [isolation](<https://devfeed.tech/tags/isolation.md>), [snapshot](<https://devfeed.tech/tags/snapshot.md>), [snapshot-isolation](<https://devfeed.tech/tags/snapshot-isolation.md>), [sql](<https://devfeed.tech/tags/sql.md>), [transaction](<https://devfeed.tech/tags/transaction.md>)

### AI overview

The excerpt argues that snapshot isolation (SI) is a practical default for many OLTP workloads because it rejects overlapping writes while avoiding serializability's broader read-write conflict checks. In the example, two transactions read rows 1 and 2, then update different rows: SI can accept both commits, allowing write skew, while serializability may reject the second because its read set overlaps the first transaction's writes. The author says avoiding such anomalies under serializability can cause more aborts or blocking, making applications more sensitive to reads and concurrency. For Aurora DSQL, lowering SI to read committed reportedly does not reduce distributed coordination, since physical clocks and MVCC provide consistent snapshots; savings in local coordination and storage multiversioning were measured as minimal. The excerpt also favors optimistic concurrency control (OCC) with MVCC: backward validation can rely on committed transaction state, and coordination can be deferred until commit, which the author says helps when coordination latency is high, such as across regions.

### Source excerpt

Snapshot Isolation vs Serializability Getting into some fundamentals. In my re:Invent talk on the internals of Aurora DSQL I mentioned that I think snapshot isolation is a sweet spot in the database isolation spectrum for most kinds of applications. Today, I want to dive in a little deeper into why I think that, and some of the trade-offs of going stronger and weaker. This post is going to be a little deeper than the last few. If you're not deeply familiar with SQL's isolation levels, I recommend checking out Crooks et al's Seeing is Believing: A Client-Centric Specification of Database Isolation, Berenson et al's A Critique of ANSI SQL Isolation Levels, or Adya et al's Generalized Isolation Level Definitions. Specifically, I'm going to talk about one very specific mental model of transaction isolation: read-write conflicts, and write-write conflicts. Let's start our journey with a transaction, T1: BEGIN; SELECT amnt FROM food WHERE id = 1 OR id = 2; UPDATE food SET amnt = amnt - 1 WHERE id = 1; COMMIT; There are a few things to notice about this transaction, when run in a database system that offers interactive (i.e. back-and-forth with the client) transactions: It directly reads two rows from the database, the rows 1 and 2 from the table food. It directly writes one row in the database, the rows 1 from the table food. It starts and ends at different times: starting during BEGIN and ending during COMMIT. Depending on the way that database is implemented, it also likely reads other data (e.g. the system catalog which tells it which tables exist), and may write other data (e.g. a secondary index on the amnt column of food). The forth point here is critical in real systems, but let's ignore it for now and focus only on the first three2. Before we do that, let's introduce a second transaction, the first one's parallel universe clone, T2. We'll also assume these are the only transactions running at this time. BEGIN; SELECT amnt FROM food WHERE id = 1 OR id = 2; UPDATE f

## DSQL Vignette: Transactions and Durability

DevFeed: [DSQL Vignette: Transactions and Durability](<https://devfeed.tech/articles/dsql-vignette-transactions-and-durability-12565.md>)

Original publisher: [Read original article](<http://brooker.co.za/blog/2024/12/05/inside-dsql-writes.html>)

Author: Marc Brooker

Published: 2024-12-05T00:00:00Z

Content type: article

Language: en

Sources: [Marc Brooker's](<https://devfeed.tech/sources/marc-brooker-s-blog.md>)

Topics: [DSQL](<https://devfeed.tech/topics/dsql.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [acid](<https://devfeed.tech/topics/acid.md>), [consistency](<https://devfeed.tech/topics/consistency.md>), [Database](<https://devfeed.tech/topics/database.md>)

Tags: [acid](<https://devfeed.tech/tags/acid.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [commit](<https://devfeed.tech/tags/commit.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [concurrency-control](<https://devfeed.tech/tags/concurrency-control.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [database](<https://devfeed.tech/tags/database.md>), [dsql](<https://devfeed.tech/tags/dsql.md>), [durability](<https://devfeed.tech/tags/durability.md>), [isolation](<https://devfeed.tech/tags/isolation.md>), [mvcc](<https://devfeed.tech/tags/mvcc.md>), [replication](<https://devfeed.tech/tags/replication.md>), [scale](<https://devfeed.tech/tags/scale.md>), [scale-out](<https://devfeed.tech/tags/scale-out.md>), [sql](<https://devfeed.tech/tags/sql.md>), [sql-database](<https://devfeed.tech/tags/sql-database.md>), [storage](<https://devfeed.tech/tags/storage.md>), [transaction](<https://devfeed.tech/tags/transaction.md>), [transaction-isolation](<https://devfeed.tech/tags/transaction-isolation.md>), [transactions](<https://devfeed.tech/tags/transactions.md>)

### AI overview

Aurora DSQL performs reads at a chosen MVCC start time and stages writes locally in the Query Processor; neither is replicated or durable until COMMIT. At commit, the adjudicator checks for writes to the same keys between the transaction's start and commit times. If there is no conflict, the committed transaction is written to the Journal, where it becomes durable and ordered; storage replicas then apply it without coordinating with one another. This combines MVCC reads with optimistic concurrency control, moving coordination to commit and requiring clients to retry commits aborted by conflicts. The article says such aborts at snapshot isolation occur when concurrent transactions write the same keys, and recommends avoiding hot write keys through schema and access-pattern design. It also describes adjudicator timestamp promises and heartbeats that let storage know it has seen all transactions needed for a consistent read. The excerpt does not give the cross-adjudicator protocol details.

### Source excerpt

DSQL Vignette: Transactions and Durability The hard half of a database system? In today's post, I'm going to look at the other half of what's under the covers of Aurora DSQL, our new scalable, active-active, SQL database. If you'd like to learn more about the product first, check out the official documentation, which is always a great place to go for the latest information on Aurora DSQL, and how to fit it into your architecture. Today, we're going to focus on writes (INSERTS, UPDATES, etc), and how transaction isolation works in Aurora DSQL. As I wrote about yesterday, reads in Aurora DSQL are done using a multiversion concurrency control (MVCC), allowing them to scale out across many replicas of many storage shards, and across a scalable SQL layer, with no contention or coordination between readers. We'd love to be able to achieve the same properties for writes, but the need to ensure that transactions are isolated from each other (the I in ACID), and ordered relative to each other (needed to get strong consistency) requires that we do some amount of coordination. The story of writes in Aurora DSQL is how and when that coordination happens. Let's consider an example transaction: START TRANSACTION; SELECT name, id FROM dogs ORDER BY goodness DESC LIMIT 1; UPDATE dogs SET latest_treat = now(), treats = treats + 1 WHERE id = 5; COMMIT; We do the read part just like we did the read part of yesterday's transaction: we choose a start time ($\tau_{start}$), and perform all our reads at that start time against our MVCC storage system. The writes proceed in a similar way: executing the UPDATE simply writes down a planned change locally inside the Query Processor (QP) that's running this transaction. No replication, durability, or writes to storage have occurred yet. That's important, because it means that the UPDATE (like the SELECT) is fast, in-region, and often in-AZ. Writing Takes Commitment The really interesting thing start with the COMMIT. We need to do three things

## DSQL Vignette: Aurora DSQL, and A Personal Story

DevFeed: [DSQL Vignette: Aurora DSQL, and A Personal Story](<https://devfeed.tech/articles/dsql-vignette-aurora-dsql-and-a-personal-story-12563.md>)

Original publisher: [Read original article](<http://brooker.co.za/blog/2024/12/03/aurora-dsql.html>)

Author: Marc Brooker

Published: 2024-12-03T00:00:00Z

Content type: article

Language: en

Sources: [Marc Brooker's](<https://devfeed.tech/sources/marc-brooker-s-blog.md>)

Topics: [DSQL](<https://devfeed.tech/topics/dsql.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [acid](<https://devfeed.tech/topics/acid.md>), [Database](<https://devfeed.tech/topics/database.md>), [consistency](<https://devfeed.tech/topics/consistency.md>), [sharding](<https://devfeed.tech/topics/sharding.md>), [Serverless](<https://devfeed.tech/topics/serverless.md>)

Tags: [atomic](<https://devfeed.tech/tags/atomic.md>), [aws](<https://devfeed.tech/tags/aws.md>), [capabilities](<https://devfeed.tech/tags/capabilities.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [database](<https://devfeed.tech/tags/database.md>), [dsql](<https://devfeed.tech/tags/dsql.md>), [enterprise](<https://devfeed.tech/tags/enterprise.md>), [hobby](<https://devfeed.tech/tags/hobby.md>), [keynote](<https://devfeed.tech/tags/keynote.md>), [local](<https://devfeed.tech/tags/local.md>), [multi-region](<https://devfeed.tech/tags/multi-region.md>), [multiple](<https://devfeed.tech/tags/multiple.md>), [optimized](<https://devfeed.tech/tags/optimized.md>), [personal](<https://devfeed.tech/tags/personal.md>), [processing](<https://devfeed.tech/tags/processing.md>), [scale](<https://devfeed.tech/tags/scale.md>), [scale-up](<https://devfeed.tech/tags/scale-up.md>), [serverless](<https://devfeed.tech/tags/serverless.md>), [sql](<https://devfeed.tech/tags/sql.md>), [story](<https://devfeed.tech/tags/story.md>)

### AI overview

Aurora DSQL is a serverless, PostgreSQL-compatible SQL database for transaction processing, with active-active multi-writer support across availability zones or regions. The excerpt says reads and writes in transactions are local; cross-region or cross-AZ latency is incurred at commit for read-write transactions, rather than on each statement. Read-only transactions and autocommit SELECTs remain local and strongly consistent. DSQL provides snapshot isolation and a subset of PostgreSQL features, and is accessed through a cluster endpoint using PostgreSQL clients, ORMs, and frameworks. AWS manages scaling, patching, fault tolerance, and durability. The author presents strong consistency and snapshot isolation as defaults intended to reduce application and tuning complexity, while noting that some existing applications may need changes and PostgreSQL feature compatibility will grow over time.

### Source excerpt

DSQL Vignette: Aurora DSQL, and A Personal Story It's happening. In this morning's re:Invent keynote, Matt Garman announced Aurora DSQL. We're all excited, and some extremely excited, to have this preview release in customers' hands. Over the next few days, I'm going to be writing a few posts about what DSQL is, how it works, and how to make the best use of it. This post is going to look at the product itself, and a little bit of a personal story. The official AWS documentation for Aurora DSQL is a great place to start to understand what DSQL is and how to use it. What is Aurora DSQL? Aurora DSQL is a new serverless SQL database, optimized for transaction processing, and designed for the cloud. DSQL is designed to scale up and down to serve workloads of nearly any size, from your hobby project to your largest enterprise application. All the SQL stuff you expect is there: transactions, schemas, indexes, joins, and so on, all with strong consistency and isolation5. DSQL offers active-active multi-writer capabilities in multiple availability zones (AZs) in a single region, or across multiple regions. Reads and writes, even in read-write transactions, are fast and local, requiring no cross-region communication (or cross-AZ communication in single region setups). Transaction commit goes across regions (for multi-region setups) or AZs (for single-regions setups), ensuring that your transactions are durable, isolated, and atomic. DSQL is PostgreSQL compatible, offering a subset of PostgreSQL's (huge) SQL feature set. You can connect with your favorite PostgreSQL client (even the psql cli), use your favorite ORMs and frameworks, etc. We'll be adding more PostgreSQL-compatible features over time, making it easy to bring your existing code to DSQL. DSQL is serverless. Here, we mean that you create a cluster in the AWS console (or API or CLI), and that cluster will include an endpoint. You connect your PostgreSQL client to that endpoint. That's all you have to do: management,

## A Race to the Bottom - Database Transactions Undermining Your AppSec

DevFeed: [A Race to the Bottom - Database Transactions Undermining Your AppSec](<https://devfeed.tech/articles/a-race-to-the-bottom-database-transactions-undermining-your-appsec-92050.md>)

Original publisher: [Read original article](<https://blog.doyensec.com/2024/07/11/database-race-conditions.html>)

Published: 2024-07-10T22:00:00Z

Content type: article

Language: en

Sources: [Doyensec](<https://devfeed.tech/sources/doyensec.md>)

Topics: [race-condition](<https://devfeed.tech/topics/race-condition.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [acid](<https://devfeed.tech/topics/acid.md>), [database-consistency](<https://devfeed.tech/topics/database-consistency.md>), [business logic](<https://devfeed.tech/topics/business-logic.md>), [OpenAPI Specification](<https://devfeed.tech/topics/openapi.md>)

Tags: [appsec](<https://devfeed.tech/tags/appsec.md>), [auditing](<https://devfeed.tech/tags/auditing.md>), [automation](<https://devfeed.tech/tags/automation.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [concurrency-control](<https://devfeed.tech/tags/concurrency-control.md>), [database](<https://devfeed.tech/tags/database.md>), [doyensec](<https://devfeed.tech/tags/doyensec.md>), [doyensecurity](<https://devfeed.tech/tags/doyensecurity.md>), [exploit](<https://devfeed.tech/tags/exploit.md>), [hacking](<https://devfeed.tech/tags/hacking.md>), [infosec](<https://devfeed.tech/tags/infosec.md>), [offensive](<https://devfeed.tech/tags/offensive.md>), [pentest](<https://devfeed.tech/tags/pentest.md>), [pentester](<https://devfeed.tech/tags/pentester.md>), [reverse-engineering](<https://devfeed.tech/tags/reverse-engineering.md>), [security](<https://devfeed.tech/tags/security.md>), [transactions](<https://devfeed.tech/tags/transactions.md>), [vulnerability](<https://devfeed.tech/tags/vulnerability.md>)

### AI overview

A database transaction alone does not prevent race conditions in business-critical operations. In a transfer example, concurrent requests can all read the same balance before updates acquire write locks, allowing overdrafts or repeated downstream actions. Testing across Postgres, MySQL, and MariaDB found exploitable cases at tested isolation levels other than Serializable; Postgres Repeatable Read was also protected by its Snapshot Isolation behavior. The article recommends Serializable isolation for critical transactions, or pessimistic locking with SELECT ... FOR UPDATE/SHARE; manual locks can be missed as code changes. Optimistic locking can detect conflicts and require retries. Semgrep rules can help inventory transactions missing isolation settings, but may produce noise and are not a complete fix.

### Source excerpt

Introduction Databases are a crucial part of any modern application. Like any external dependency, they introduce additional complexity for the developers building an application. In the real world, however, they are usually considered and used as a black box which provides storage functionality. This post aims shed light on a particular aspect of the complexity databases introduce which is often overlooked by developers, namely concurrency control. The best way to do that is to start off by looking at a fairly common code pattern we at Doyensec see in our day-to-day work: func (db *Db) Transfer(source int, destination int, amount int) error { ctx := context.Background() conn, err := pgx.Connect(ctx, db.databaseUrl) defer conn.Close(ctx) // (1) tx, err := conn.BeginTx(ctx) var user User // (2) err = conn. QueryRow(ctx, "SELECT id, name, balance FROM users WHERE id = $1", source). Scan(&user.Id, &user.Name, &user.Balance) // (3) if amount <= 0 || amount > user.Balance { tx.Rollback(ctx) return fmt.Errorf("invalid transfer") } // (4) _, err = conn.Exec(ctx, "UPDATE users SET balance = balance - $2 WHERE id = $1", source, amount) _, err = conn.Exec(ctx, "UPDATE users SET balance = balance + $2 WHERE id = $1", destination, amount) // (5) err = tx.Commit(ctx) return nil } Note: All error checking has been removed for clarity. For the readers not familiar with Go, here's a short summary of what the code is doing. We can assume that the application will initially perform authentication and authorization on the incoming HTTP request. When all required checks have passed, the db.Transfer function handling the database logic will be called. At this point the application will: 1. Establish a new database transactions 2. Read the source account's balance 3. Verify that the transfer amount is valid with regard to the source account's balance and the application's business rules 4. Update the source and destination accounts' balances appropriately 5. Commit the database transacti

## Rate Limiting at the Application Layer

DevFeed: [Rate Limiting at the Application Layer](<https://devfeed.tech/articles/rate-limiting-at-the-application-layer-81429.md>)

Original publisher: [Read original article](<https://stack.convex.dev/rate-limiting>)

Author: Stack

Published: 2024-05-21T19:00:26Z

Content type: tutorial

Language: en

Sources: [Stack](<https://devfeed.tech/sources/stack.md>)

Topics: [rate-limiting](<https://devfeed.tech/topics/rate-limiting.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [acid](<https://devfeed.tech/topics/acid.md>), [database-scalability](<https://devfeed.tech/topics/database-scalability.md>), [App](<https://devfeed.tech/topics/app.md>), [Serverless](<https://devfeed.tech/topics/serverless.md>)

Tags: [acid](<https://devfeed.tech/tags/acid.md>), [authorization](<https://devfeed.tech/tags/authorization.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [convex](<https://devfeed.tech/tags/convex.md>), [database](<https://devfeed.tech/tags/database.md>), [patterns](<https://devfeed.tech/tags/patterns.md>), [rate-limiting](<https://devfeed.tech/tags/rate-limiting.md>), [token-bucket](<https://devfeed.tech/tags/token-bucket.md>)

### AI overview

This tutorial explains how to implement application-layer rate limiting with token-bucket and fixed-window approaches using a database with transactional guarantees. It covers reservations, jitter, sharding, and coordinating multiple limits, with examples using Convex.

### Source excerpt

Implementing application rate limiting when you have fast access to a database with strong ACID guarantees. Token bucket and fixed window, with fairness, burst accommodation and fire-and-forget support.

## Distributed transactions: What, why, and how to build a distributed transactional application

DevFeed: [Distributed transactions: What, why, and how to build a distributed transactional application](<https://devfeed.tech/articles/distributed-transactions-what-why-and-how-to-build-a-distributed-transactional-application-23780.md>)

Original publisher: [Read original article](<https://cockroachlabs.com/blog/distributed-transactions-what-why-and-how-to-build-a-distributed-transactional-application>)

Author: Charlie Custer

Published: 2023-02-16T00:00:00Z

Content type: article

Language: en

Sources: [Cockroach Labs](<https://devfeed.tech/sources/cockroach-labs.md>)

Topics: [Transactions](<https://devfeed.tech/topics/transactions.md>), [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [Database](<https://devfeed.tech/topics/database.md>), [CockroachDB](<https://devfeed.tech/topics/cockroachdb.md>), [database-consistency](<https://devfeed.tech/topics/database-consistency.md>), [Raft](<https://devfeed.tech/topics/raft.md>), [acid](<https://devfeed.tech/topics/acid.md>)

Tags: [availability](<https://devfeed.tech/tags/availability.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [database](<https://devfeed.tech/tags/database.md>), [distributed-transactions](<https://devfeed.tech/tags/distributed-transactions.md>), [fault-tolerance](<https://devfeed.tech/tags/fault-tolerance.md>), [high-availability](<https://devfeed.tech/tags/high-availability.md>), [scalability](<https://devfeed.tech/tags/scalability.md>), [transactions](<https://devfeed.tech/tags/transactions.md>)

### AI overview

Distributed transactions coordinate data changes across database nodes, preserving the all-or-nothing behavior expected of a transaction. The article compares three patterns: two-phase commit keeps nodes consistent by requiring each to prepare and then commit, but locks resources, can bottleneck, and fails if any node is unavailable. Active-passive replicas allow a passive node to take over after an active-node failure, though failover can cause a brief outage and writes remain limited to one node. In a multi-active system such as CockroachDB, all nodes can handle reads and writes; Raft lets a transaction commit when a majority agree, and the database manages routing and consistency. This can support scaling and availability while preserving consistency, but building such a system from scratch is highly complex, so adopting it generally means choosing or migrating to a purpose-built database.

### Source excerpt

Transactions make up an important part of the database workload for most modern applications. And when it comes time to scale up operations for a growing business, distributing those workloads across multiple hardware systems for horizontal scalability, high availability, and fault tolerance is often an important part of the plan.

## Atomic Commitment: The Unscalability Protocol

DevFeed: [Atomic Commitment: The Unscalability Protocol](<https://devfeed.tech/articles/atomic-commitment-the-unscalability-protocol-12525.md>)

Original publisher: [Read original article](<http://brooker.co.za/blog/2022/10/04/commitment.html>)

Author: Marc Brooker

Published: 2022-10-04T00:00:00Z

Content type: article

Language: en

Sources: [Marc Brooker's](<https://devfeed.tech/sources/marc-brooker-s-blog.md>)

Topics: [Transactions](<https://devfeed.tech/topics/transactions.md>), [acid](<https://devfeed.tech/topics/acid.md>), [protocols](<https://devfeed.tech/topics/protocols.md>), [software-architecture](<https://devfeed.tech/topics/software-architecture.md>)

Tags: [analysis](<https://devfeed.tech/tags/analysis.md>), [atomic](<https://devfeed.tech/tags/atomic.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [computer-science](<https://devfeed.tech/tags/computer-science.md>), [data](<https://devfeed.tech/tags/data.md>), [database](<https://devfeed.tech/tags/database.md>), [dataset](<https://devfeed.tech/tags/dataset.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [machines](<https://devfeed.tech/tags/machines.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [router](<https://devfeed.tech/tags/router.md>), [routing](<https://devfeed.tech/tags/routing.md>), [scaling](<https://devfeed.tech/tags/scaling.md>), [transaction](<https://devfeed.tech/tags/transaction.md>), [two-phase-commit](<https://devfeed.tech/tags/two-phase-commit.md>), [write](<https://devfeed.tech/tags/write.md>)

### AI overview

Sharding can increase transaction throughput only when transactions touch few shards. With s shards and mean shard participation k, the excerpt estimates capacity as proportional to s/k; under uniform key selection, k = s(1 − ((s−1)/s)^N), where N is rows per transaction. For N=10, the model says adding a second shard raises maximum throughput by only about 1%. Concurrent transactions can fare worse: two transactions needing both shards may each reserve capacity on a different shard and both fail. A simulation described in the excerpt, using Poisson arrivals, heavy offered load and uniform keys, shows goodput falling as shard count grows before recovering at six shards. The author concludes that atomic commitment's coordination can undermine scale-out; the model's distribution assumption and excerpted simulation limit how broadly to apply the results.

### Source excerpt

Atomic Commitment: The Unscalability Protocol 2PC is my enemy. Let's consider a single database system, running on one box, good for 500 requests per second. ┌───────────────────┐ │ Database │ │(good for 500 rps) │ └───────────────────┘ What if we want to access that data more often than 500 times a second? If by access we mean read, we have a lot of options. If be access, we mean write or even perform arbitrary transactions on, we're in a trickier situation. Tricky problems aside, we forge ahead by splitting our dataset into two shards: ┌───────────────────┐ ┌───────────────────┐ │ Database shard 1 │ │ Database shard 2 │ │(good for 500 rps) │ │(good for 500 rps) │ └───────────────────┘ └───────────────────┘ If we're just doing single row reads and writes, we're most of the way there. We just need to add a routing layer that can decide which shard to send each access to, and we're done1: ┌────────────┐ │ Router │ └────────────┘ ┬ ┌─────────┴───────────┐ ▼ ▼ ┌───────────────────┐ ┌───────────────────┐ │ Database shard 1 │ │ Database shard 2 │ │(good for 500 rps) │ │(good for 500 rps) │ └───────────────────┘ └───────────────────┘ But what if we have transactions? To make the complexity reasonable, and speed us on our journey, let's define a transaction as an operation that does writes to multiple rows, based on some condition, atomically. By atomically we mean that either all the writes happen or none of them do. By based on some condition we mean the transactions can express ideas like "reduce my bank balance by R10 as long as it's over R10 already". But how do we ensure atomicity across multiple machines? This is a classic computer science problem called Atomic Commitment. The classic solution to this classic problem is Two-phase commit, maybe the most famous of all distributed protocols. There's a lot we could say about atomic commitment, or even just about two-phase commit. In this post, I'm going to focus on just one aspect: atomic commitment has weird scaling be

## What write skew looks like

DevFeed: [What write skew looks like](<https://devfeed.tech/articles/what-write-skew-looks-like-23825.md>)

Original publisher: [Read original article](<https://cockroachlabs.com/blog/what-write-skew-looks-like>)

Author: Justin Jaffray

Published: 2022-03-31T00:00:00Z

Content type: article

Language: en

Sources: [Cockroach Labs](<https://devfeed.tech/sources/cockroach-labs.md>)

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

Tags: [concurrency](<https://devfeed.tech/tags/concurrency.md>), [cycles](<https://devfeed.tech/tags/cycles.md>), [database](<https://devfeed.tech/tags/database.md>), [isolation](<https://devfeed.tech/tags/isolation.md>), [isolation-level](<https://devfeed.tech/tags/isolation-level.md>), [snapshot-isolation](<https://devfeed.tech/tags/snapshot-isolation.md>), [transaction](<https://devfeed.tech/tags/transaction.md>), [write-skew](<https://devfeed.tech/tags/write-skew.md>)

### AI overview

Snapshot Isolation gives each transaction a consistent read snapshot and prevents concurrent transactions from writing overlapping sets, yet it can still allow nonserializable write skew. In the example, one transaction copies x to y while another copies y to x; each reads before the other commits and writes a different location, producing a swap that no serial ordering permits. The article explains how to identify such anomalies with a serialization graph: dependencies form edges, and a cycle means the history is not serializable. Under Snapshot Isolation, any cycle contains consecutive concurrent read-write anti-dependencies. Serializable Snapshot Isolation uses this pattern to track transactions involved in anti-dependencies on both sides and abort a transaction or a neighbor, preventing cycles while sometimes aborting transactions that were not themselves part of a cycle. The article also argues that serializability simplifies invariant checking: each transaction can be checked on its own, whereas weaker isolation requires reasoning about interactions among transactions.

### Source excerpt

Syndication from What Does Write Skew Look Like by Justin Jaffray This post is about gaining intuition for Write Skew, and, by extension, Snapshot Isolation. Snapshot Isolation is billed as a transaction isolation level that offers a good mix between performance and correctness, but the precise meaning of "correctness" here is often vague. In this post I want to break down and capture exactly when the thing called "write skew" can happen.

## PostgreSQL as a Microservice

DevFeed: [PostgreSQL as a Microservice](<https://devfeed.tech/articles/postgresql-as-a-microservice-34614.md>)

Original publisher: [Read original article](<https://tapoueh.org/blog/2021/06/postgresql-as-a-microservice/>)

Author: Dimitri Fontaine PostgreSQL Major Contributor; Author

Published: 2021-06-08T11:40:00Z

Content type: opinion

Language: en

Sources: [Dimitri Fontaine](<https://devfeed.tech/sources/dimitri-fontaine.md>)

Topics: [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Microservices](<https://devfeed.tech/topics/microservices.md>), [software-architecture](<https://devfeed.tech/topics/software-architecture.md>), [acid](<https://devfeed.tech/topics/acid.md>), [rdbms](<https://devfeed.tech/topics/rdbms.md>)

Tags: [acid](<https://devfeed.tech/tags/acid.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [rdbms](<https://devfeed.tech/tags/rdbms.md>)

### AI overview

The article examines PostgreSQL as a potential microservice and argues that its distinctive value is not merely storage. It emphasizes PostgreSQL's role in managing concurrent access to data while providing guarantees such as ACID properties, schemas, and constraints.

### Source excerpt

The MACI French podcast honoured me with an invitation to a guest appearance on their weekly schedule. As you can imagine, we talked about many things related to PostgreSQL... and also reacted to some newsworthy articles carefully curated by the MACI team. One of the topics we discussed in the podcast started with looking at PostgreSQL through the angle of it being one of the microservices that your application would be composed of.

## PostgreSQL Concurrency: Isolation and Locking

DevFeed: [PostgreSQL Concurrency: Isolation and Locking](<https://devfeed.tech/articles/postgresql-concurrency-isolation-and-locking-34603.md>)

Original publisher: [Read original article](<https://tapoueh.org/blog/2018/07/postgresql-concurrency-isolation-and-locking/>)

Author: Dimitri Fontaine PostgreSQL Major Contributor; Author

Published: 2018-07-03T11:30:13Z

Content type: tutorial

Language: en

Sources: [Dimitri Fontaine](<https://devfeed.tech/sources/dimitri-fontaine.md>)

Topics: [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [consistency](<https://devfeed.tech/topics/consistency.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [acid](<https://devfeed.tech/topics/acid.md>)

Tags: [acid](<https://devfeed.tech/tags/acid.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [locking](<https://devfeed.tech/tags/locking.md>), [pg-dump](<https://devfeed.tech/tags/pg-dump.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [transactions](<https://devfeed.tech/tags/transactions.md>)

### AI overview

This primer explains PostgreSQL isolation and locking as mechanisms for handling concurrent access while maintaining consistency. It discusses ACID-compliant transactions, isolation levels, locking control, and the snapshot behavior used by pg_dump for backups.

### Source excerpt

PostgreSQL is a relational database management system. It's even the world's most advanced open source one of them. As such, as its core, Postgres solves concurrent access to a set of data and maintains consistency while allowing concurrent operations. This article is a primer on PostgreSQL Isolation and Locking properties and behaviors. You might be interested into the previous article in the series: PostgreSQL Concurrency: Data Modification Language.

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