DEV Community: Nafas Ebrahimi

About : The 4 Pillars of Database Reliability

Nafas Ebrahimi — Mon, 01 Jun 2026 12:39:17 +0000

Have you ever wondered what happens behind the scenes when you transfer money online, book a flight, or buy a movie ticket? How do databases ensure that your money doesn’t just “disappear” mid-transfer if the internet cuts out?

The secret weapon behind this reliability is a concept called ACID.

In this quick guide, we’ll break down what ACID means in plain English, using simple real-world examples. Let’s dive in!

What is ACID?

ACID is not a database architecture, but rather a set of four fundamental properties that guarantee database transactions are processed reliably. If a database follows these rules, we call it ACID-compliant (like PostgreSQL, MySQL, or SQL Server).

A “transaction” is simply a sequence of operations treated as a single unit of work. ACID ensures these transactions never mess up your data.

Here is what the acronym stands for:

1- A - Atomicity (All or Nothing)
2- C - Consistency (Rules are Rules)
3- I - Isolation (No Interferences)
4- D - Durability (Built to Last)

Let's get into these!

1. Atomicity: The “All-or-Nothing” Rule

Imagine you are transferring 100 dollar bills to your friend. This requires two steps:

Deducting $100 from your account.
Adding $100 to your friend’s account.
What if the database crashes right after step 1? Your money would vanish!

Atomicity prevents this. It treats the transaction as a single “atom” that cannot be split. Either both steps succeed, or none of them do. If a failure occurs mid-way, the database performs a rollback, putting everything back to exactly how it was.

2. Consistency: Keeping the Rules Sacred

Every database has pre-defined rules, constraints, and triggers. Consistency ensures that a transaction can only bring the database from one valid state to another.

For example, if your bank database has a rule that account balances can never go below zero Consistency will instantly block any transaction that attempts to withdraw more money than you actually have. The database remains healthy and error-free.

3. Isolation: Mind Your Own Business

In the real world, thousands of users are interacting with a database at the exact same millisecond. Isolation ensures that concurrent transactions don’t trip over each other.

Imagine there is only one seat left for a blockbuster movie, and two users click “Buy” at the exact same second. Isolation forces the database to process them sequentially. User A completes their purchase securely, and User B is politely informed that the seat is gone—preventing the nightmare of double-booking.

4. Durability: Written in Stone

Once a transaction is successfully completed (committed), it must persist—even if the database server suddenly loses power, catches fire, or crashes a second later.

Durability guarantees that completed changes are permanently recorded in non-volatile memory (like your hard drive or SSD) and transaction logs, making them safe from any system failure.

When I Learned Python, I Made a CLI Tool

Nafas Ebrahimi — Thu, 28 May 2026 10:05:48 +0000

Three months ago, I decided to learn Python.

why?

Python gives me power to make everything. most of the developers know it and it has a rich community.

And I did it.

As a programmer who learned Rust language (I will tell you how to learn this and what I did), Python is very easy to learn for me and I learned in 1 week with internet problems.

I was working on a website project and needed to compress some asset images because they are huge. unfortunately, I couldn't access image compressor websites (As Iranian we are in blackout). so, I'd decided to make a CLI tool to compress images. (It doesn't convert images to thumbnail)

And after that I made this tool with Python.

This is my first project with Python. Tinypixels: This is Tinypixels repo

This is one thing to learn everything

Nafas Ebrahimi — Thu, 21 May 2026 10:01:59 +0000

This is my article here, and maybe later I will share something.

I read the Smarter Faster Better book by Charles Duhigg. This book is very great for improving your productivity. The book has interesting things to learn.

The one thing that caught my attention is working with data. I'm not talking about technical things.

Data can be anything. From the time you go to sleep, to how you deal with stuff, even knowledge.

As a programmer, we have a lot of things to learn, and we don't have enough time to learn all of them unfortunately.

Usually on weekends, as we have free time, we spend the whole day learning.

The frustrating thing is we forget most of them. So what should we do?

The book says we should work with the data, analyze it, discuss it with someone (it can be your colleague), do tests, and review it over and over.

For example, last weekend I learned a new Python function. Instead of just reading it, I wrote a small test for it, explained it to a coworker on Monday, and reviewed it again on Tuesday. Now I still remember it clearly.

Next time you learn something new, try testing it, talking about it, and reviewing it. You might be surprised how much more you remember.