Merkle Tree

Merkle Root

Merkle Patricia Trie

Blockchain

Blockchain Technology

A Post-Grad’s Quest to Understand the Merkle Tree

Kerala Blockchain Academy

9 min readNov 7, 2025

Darshan K, Blockchain Student, Digital University Kerala

I had thought blockchain’s core promise was impossible; It was at the KBA Blockchain lecture on an idea from the 1970s that changed everything.

I was sitting in my blockchain lecture when our tutor said something that just woke up my sleepy brain.

I’m a first-year post-graduate student. I’m supposed to be here in order to learn the deep, complex stuff. But as I sat in that lecture hall, I was convinced I’d fundamentally misunderstood the last ten minutes of class.

The tutor — calm as always — said: “And so, with a Merkle Tree, your phone can verify that your one transaction is included in a 500-gigabyte blockchain and that too without downloading the blockchain.”

I just stared.

My mind was stuck even though I had a little bit of fundamentals regarding what merkle root was in the block level. I was like How?

How could you possibly know one tiny, specific piece of data is correct without having all the data to check against?

It felt like a logic puzzle that had no answer. It felt like trying to prove there is one specific sentence in a library of 100 thousand books. and only being allowed to read the head librarian’s ID card. It felt like magic. It felt, frankly, impossible.

The problem? I was thinking like a librarian, who has to find the book on the shelf. The solution was to think like a detective, who just needs a single perfect fingerprint.

I did not yet understand the simple, powerful genius of a Merkle Tree.

Before we get to the “yess!” moment, let’s sit with the “that’s impossible!” moment. Because that’s where all great learning starts.

My brain, immediately went to the “brute-force” solution.

Let’s say one “block” in the blockchain is a big box containing 4,000 transactions from the last 10 minutes. My transaction, say, buying a coffee, is included among these 4,000.

If I want to prove to a new friend that my coffee transaction is really in that block, what’s the obvious way to do it?

First thought: “Easy. I’ll just ask the network, ‘Hey, can you send me that entire block?’”

My phone would explode. I’d download the entire, heavy box. Then, I’d open it and dump all 4,000 transactions onto my table. I’d sift through them, one at a time. “Nope. nope. ah, here it is! Transaction #2,998! See? I told you.”

It works. But it’s terrible just like using linear search in its worst case.

It’s the “boil the ocean to make a cup of tea”method. It’s slow, it’s heavy, and it wastes massive amounts of data and processing power. Now, scale that up. A blockchain isn’t one box; it is a warehouse of boxes the size of a continent. You cannot download a 500GB+ warehouse to your phone just to prove one thing.

If this were the only way, blockchain would be a failed experiment-a clunky tool only usable by massive data centers. There would not be crypto wallets on your phone, and no quick verification.

This is the problem that keeps computer scientists up at night. And it was solved, not in the 2010s, but in 1979 by a man named Ralph Merkle.

The First Clue: The Digital Fingerprint

The first piece of the puzzle isn’t the tree; it’s the “hash.”

If you’re new to this, please don’t let that word scare you. A “hash function” is just a magic digital blender.

You can put anything into this blender.

The complete text of War and Peace. A 4K movie file. The single letter “a”.

You hit “blend,” and out comes a single, unique, fixed-length string of text. This text is its “hash.” It looks something like this: e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855

This magic blender has a few crucial rules:

It’s a one-way street. You can put the book in to get the hash, but you can never get the book back from the hash. It’s a “fingerprint,” not a “ZIP file.”
It’s deterministic: If you put War and Peace in today, and again in ten years, you will get the exact same hash. Every single time.
It’s an avalanche. This is the most important part. If you change one single comma in War and Peace and put it back in the blender, the hash that comes out will be completely and unrecognizably different.
This “avalanche effect” is our detective’s tool. It’s an infallible, perfect fingerprint for any piece of data. If the fingerprint matches, the data is identical. If it’s even 0.00001% different, the fingerprint won’t match.

All right. So we have digital fingerprints: We can take our 4,000 transactions and give each a unique hash.

Now we’ve got 4,000 hashes. We are still drowning in data. What’s next?

The “Yess!” Moment: Hashing the Hashes

This is the part of the lecture that I started to lean forward.

Ralph Merkle’s idea was simple: “What if we don’t just fingerprint the data? What if we fingerprint the fingerprints?

Let’s build one. Forget 4,000 transactions, let’s start with eight, to make things easy. Let’s call them Transactions A, B, C, D, E, F, G and H.

This is our “leaf” layer. We now have 8 fingerprints.

Level 1 : The Branches Now the magic. We pair them up.

We take H(A) and H(B), stick them together, and blend them. Now we have a new hash, say: H(AB).
We do the same for C and D to get H(CD).
and for E and F to get H(EF).
and for G and H to get H(GH).
We began with 8 hashes. Now we have 4. We’re building a pyramid.

Level 2: More Branches Let’s do it again.

We take the H(AB) and H(CD), combine them, and mix. The result is H(ABCD).
We are taking H(EF) and H(GH) and combine them. So we get H(EFGH).
Now we have just 2 hashes.

Level 3: The Root One last time.

We take H(ABCD) and H(EFGH), stick them together, and blend.
This gives us one single hash.
This final hash — this “hash of all hashes” has a special name. It’s called the Merkle Root.

This one single 32-byte string of text is the “master fingerprint” for the entire block of 8 transactions. It’s the fingerprint of the fingerprints of the fingerprints.

Because of the “avalanche effect,” if someone tries to secretly change Transaction G just a little tiny bit, H( G) will change. This will make H( GH) change. This will make H( EFGH) change. And this, in turn, will make the final Merkle Root completely different.

Merkle Root represents the perfect, tamper-proof summary of all the data beneath it. It’s the ID card on the librarian that proves the state of every book in the library.

The Magic Trick, Explained

My mind was spinning. I saw how it was built, but how does this solve my “impossible” problem?

Let’s go back to the scenario. I am the detective. Let me try to show my friend that my transaction, Transaction F, is in this block.

The following are not needed: I do not need Transaction A, B, C, D, E, G and H. I can discard 7 out of the 8 transactions.

Here is what I do need. It’s a “proof kit” for Transaction F:

My transaction Transaction F: I have this. I can compute its hash, H(F), myself
The Merkle Root: This is public. It’s written on the “outside” of the block — that is to say, in the block header. Think of it as the official seal on the library door.
The “Merkle Path”: this is the magic part, I only need to request a couple of helper hashes from the network.

What are the helpers I need to reconstruct the pyramid, starting with my H( F)?

Looking at the tree, to get to the top, I need:

So, it doesn’t send me all 8 transactions over the network. It just sends three hashes: H( E), H( GH) and H( ABCD).

This is my “Merkle Path.”

I take my H( F) and mix it with the H( E) they sent me. I combine them.

My_H(EF) = hash( H(E) + H(F) )

I take the result, My_H( EF), and I combine it with the H( GH) they sent me. I mix them together.

My_H(EFGH) = hash( My_H(EF) + H(GH) )

I take that result, My_H( EFGH), and mix it with the H( ABCD) that they have sent me. I combine them.

My_ROOT = hash( H(ABCD) + My_H(EFGH) )

I now have a final “root” hash, calculated by myself.

This is the moment of truth.

I compare My_ROOT to the block’s official public MERKLE ROOT.

They match.

It’s proof. Undeniable, mathematical proof. I have just proven, with 100% certainty, that my Transaction F is a part of that tree.

And to do it, I only needed to download 3 tiny hashes, not 8 entire transactions.

Why This Is Not Just Cool, But Revolutionary

Now, scale this up.

A real block has 4,000 transactions. How many “helper hashes” would I need?

8 transactions required 3 assistants.

16 transactions would require 4 helpers.

4,000 transactions would require. only 12 helpers.

That’s the magic of logarithmic scaling : log2( N). To verify one transaction out of a million, I’d need roughly only 20 helper hashes.

This is what my tutor meant. This is, in fact, the whole basis for “Simple Payment Verification” and all.

Your phone doesn’t need to be a “full node” — a huge librarian computer that holds all 500GB of the library’s books. It could be a “light client” — a detective who just walks in with a fingerprint kit.

This is why you can have a crypto wallet on your phone that actually works.

“But wait,” — “What if the network lies? What if they send me a fake H(E)?”

The best part is — it does not work.

Because if a malicious node sends me a fake H( E), the My_H( EF) I compute will be wrong. Then the My_H( EFGH) I compute will be wrong. And at the very end, the My_ROOT I generate will fail to correspond with the official Merkle Root.

The lie is detected mathematically in an instant. I can simply say, “Proof invalid. Try again,” and ask a different node.

The Merkle tree isn’t providing proof-so much as tamper-detection. It’s a way of turning “trust, but verify” into just “verify.”

This Tree Has Roots Everywhere

I left that lecture feeling my head spinning-in the best possible way, of course. That feeling of “it’s impossible” had been replaced by that “yess!” that every student-and human-lives for.

This isn’t just a blockchain thing.

Git: Have you ever wondered how Git, the system that developers use, knows exactly which line you changed in a 50,000-file project? It is based on a variant of a Merkle Tree. Every file, every directory, every “commit” is a hash, all the way up to the single “master hash” for the project.
BitTorrent: How does your computer know that the piece of a movie you just downloaded from a total stranger in another country is the real piece and not a virus? Because the original .torrent file you downloaded contained a Merkle Root of all the pieces. Your client hashes the piece it got and checks it against the master list.
Databases: High-performance databases like Cassandra and DynamoDB use Merkle Trees to sync data across the globe, quickly find inconsistencies without having to send all the data back and forth.

This isn’t some obscure, new “crypto” idea. This is a fundamental, time-tested, brilliant piece of computer science from 1979. The best of computer science isn’t about some really complex, intimidating algorithms. It’s about finding beautifully simple, elegant solutions to very big, very human problems. Problems like:

“How can I trust you?”

“How can I prove this is real?”

“How can we all agree on what happened, without having to ask one person to be the boss?”

The Merkle tree is one of the most elegant solutions ever designed. It’s a data structure that quite literally creates trust from the ground up. And in a digital world where everything can be faked, copied, and deep-faked, a little bit of provable, mathematical trust feels less like a magic trick and more like a miracle.

Now, if you feel like trying this out on your own. I have two websites that lets you play around with Merkle Tree :

https://learnapps.kba.ai/merkle