Coder Legion - Recent posts tagged acidtransactions

Demystifying ACID Transactions: How to Keep Your Database from Making a Mess

Thu, 01 Oct 2026 10:28:33 +0000

An ACID transaction is a set of four database safety rules—Atomicity, Consistency, Isolation, and Durability—that ensure database operations are executed reliably. It guarantees that even if your application crashes, loses power, or experiences thousands of concurrent requests, your data remains accurate and uncorrupted. Simply put, it ensures your database never ends up in a half-finished, broken state.

The Ticket Booth Analogy

Imagine buying a physical ticket at a busy movie theater box office. You hand the cashier a $15 bill, and they hand you the ticket. This exchange must happen as a single, indivisible unit. If you hand over your cash, but a sudden power outage occurs before the cashier can hand you the ticket, you would be furious if they kept your money. Conversely, the theater would lose out if you grabbed the ticket and walked away without paying.

The transaction is "all-or-nothing": either the cash changes hands and you get the ticket, or the entire deal is canceled, and you keep your money. ACID acts as this strict box-office coordinator for your software's database, ensuring that multi-step operations never stop halfway.

Why It Matters: Real-World Disasters

In daily software engineering, we rely on ACID transactions to prevent catastrophic data errors, especially when building systems like financial ledgers, e-commerce checkouts, or reservation platforms.

Without ACID, imagine a bank transfer system built on Node.js. When a user transfers $100, the system must perform two separate actions: deduct $100 from Account A, and add $100 to Account B. If the database server loses connection exactly halfway through this process, Account A loses money, but Account B never receives it. The $100 vanishes into the digital void.

Similarly, in a high-traffic retail store, if two customers try to buy the very last item in stock at the exact same millisecond, a non-ACID database might let both transactions complete. This leaves you with an oversold item and an angry customer. By grouping these operations inside an ACID transaction, developers ensure that if any step fails, the database automatically rolls back all changes, restoring everything to its original state.

Implementing ACID in Node.js and MySQL

Here is how we can implement a secure money transfer using Node.js and the standard mysql2/promise library. By wrapping our queries in a transaction block, we guarantee data safety.

const mysql = require('mysql2/promise');

async function transferFunds(fromAccountId, toAccountId, amount) {
  const connection = await mysql.createConnection({
    host: 'localhost',
    user: 'root',
    database: 'bank_db'
  });

  try {
    // Start the ACID transaction
    await connection.beginTransaction();

    // Step 1: Deduct from the sender's account
    const [deductResult] = await connection.execute(
      'UPDATE accounts SET balance = balance - ? WHERE id = ? AND balance >= ?',
      [amount, fromAccountId, amount]
    );

    if (deductResult.affectedRows === 0) {
      throw new Error('Insufficient funds or invalid sender account');
    }

    // Step 2: Add to the receiver's account
    const [creditResult] = await connection.execute(
      'UPDATE accounts SET balance = balance + ? WHERE id = ?',
      [amount, toAccountId]
    );

    if (creditResult.affectedRows === 0) {
      throw new Error('Invalid receiver account');
    }

    // If both steps succeed, permanently commit the changes to disk
    await connection.commit();
    console.log('Transaction completed successfully!');
  } catch (error) {
    // If anything fails, revert all changes immediately
    await connection.rollback();
    console.error('Transaction failed. Rolled back changes:', error.message);
  } finally {
    await connection.end();
  }
}

The Takeaway

ACID transactions are the ultimate insurance policy for your application's state. While they introduce a minor performance trade-off due to locking rows during updates, they completely eliminate the need to write complex, error-prone fallback code. Shifting the responsibility of data integrity to your database engine lets you sleep easy knowing your system will never tell a lie.

Originally published on my blog. You can read the alternative breakdown here.

Demystifying ACID Transactions: How Databases Prevent Chaos and Keep Your Data Safe

Tue, 08 Sep 2026 08:20:04 +0000

If you have ever used an online app to transfer money, buy a concert ticket, or update your profile, you have relied on a database. Behind the scenes, databases must process millions of instructions without making mistakes, even if the power suddenly cuts out or the server crashes. To guarantee this level of safety, databases rely on a concept called an ACID transaction, which is a set of four rules designed to keep your data perfectly accurate, clean, and trustworthy.

The Analogy: The Vending Machine

To understand how an ACID transaction works, imagine buying a bag of chips from a vending machine. This simple action relies on several rules to make sure nobody gets cheated:

Atomicity (All-or-Nothing): You enter your money and press the button. Either you get your chips and the machine keeps your money, or the machine jams, returns your cash, and keeps the chips. You will never experience a state where the machine keeps your money but does not give you the chips.
Consistency (Rule Following): The machine must always balance its books. If a bag of chips costs two dollars, the machine's internal tally must show exactly two dollars more in cash and one fewer bag of chips in inventory. It cannot end up with a random, unexplainable state.
Isolation (Privacy): If two people press buttons on the vending machine at the exact same moment, the machine processes one transaction first, finishes it completely, and then processes the second. The two orders do not get mixed up, and you do not end up getting each other's snacks.
Durability (Permanence): Once your chips drop into the retrieval slot, they are yours. If the power outlet is pulled from the wall a millisecond later, the chips do not magically fly back up into the machine. The physical transfer is permanent.

Why It Matters in Tech

Without ACID transactions, software development would be an absolute nightmare. Imagine writing code for a banking system without these guarantees. If a customer transfers fifty dollars from Account A to Account B, the system must perform two database updates: subtract fifty from Account A, and add fifty to Account B.

If the server crashes exactly halfway through this process, fifty dollars could simply vanish into thin air. Engineers use ACID transactions to bundle these two updates into a single, bulletproof package. If any part of the process fails, the database automatically rolls back to the beginning, behaving as if the transfer never started, protecting the user's money and the business's reputation.

Seeing It in Action

Here is a simple example in JavaScript using a hypothetical database library. It shows how we bundle multiple database operations into a single, safe transaction:

async function transferMoney(senderId, receiverId, amount) {
  // 1. Start the transaction block
  await database.query("BEGIN TRANSACTION");

  try {
    // 2. Subtract the amount from the sender
    await database.query(
      "UPDATE accounts SET balance = balance - $1 WHERE id = $2", 
      [amount, senderId]
    );

    // 3. Add the amount to the receiver
    await database.query(
      "UPDATE accounts SET balance = balance + $1 WHERE id = $2", 
      [amount, receiverId]
    );

    // 4. If both succeeded, lock in the changes permanently
    await database.query("COMMIT");
    console.log("Transfer completed successfully!");
  } catch (error) {
    // 5. If ANY error occurred, cancel and reverse all changes
    await database.query("ROLLBACK");
    console.error("Transfer failed. System rolled back to safety:", error);
  }
}

The Takeaway

ACID transactions are the unsung heroes of software reliability, transforming chaotic and unpredictable environments into predictable, safe spaces. By ensuring that database operations either succeed completely or fail harmlessly without a trace, they give developers the confidence to build robust systems that users can trust with their most sensitive financial, personal, and operational data.

Resources

GitHub Repository: react-hook-lab
react-hook-lab: npm package
Connect with me on LinkedIn: Saurav Pandey

Originally published on my blog. You can read the alternative breakdown here.