You now have the cryptographic primitives. Hashes that uniquely identify data, keys that prove identity, signatures that bind authorship to a message, Merkle trees that commit to large sets in 32 bytes. Standing alone, none of these is a blockchain. A blockchain is what happens when you arrange those primitives in a very specific way to solve a very specific problem. This lesson builds the structure up from scratch, using only the parts you already have.

You want a shared record of facts. A list of "this happened, then this happened, then this happened." Many parties around the world need to agree on the contents of that list. None of them trusts any of the others. There is no central authority you can all defer to.

That's the entire problem. Build a list of facts that everyone can read, anyone can append to, and nobody can secretly edit. With no admin.

It sounds impossible at first. If everyone has their own copy of the list, who's right when two copies disagree? If anyone can write to it, what stops a bad actor from rewriting history? If there's no central operator, how does the system decide which version of reality is the real one?

The blockchain is the answer to all of those questions at once. It works because of one structural choice that everything else flows from.

Step one. You need to record a list of items, in order. Call them "items" for now since we haven't told you what they are yet. The list grows over time as new items are added.

A naive list would look like this:

item 1
item 2
item 3
item 4
...

This works for one person on one computer. The problem starts when the list is shared. If you mail me a copy and I quietly change item 2 to say something different, you have no way to tell from my copy that anything is wrong. The list has no built-in defence against tampering.

Step two. Apply what you learned about hashing. Group items into batches called blocks, and each block carries the hash of the previous block. Tampering with any historical block changes its hash, which means the next block's "previous hash" field no longer matches, which means the chain breaks. Anyone holding the chain can detect this by recomputing one hash per block.

[Block 1: items]  →  [Block 2: items, prev_hash]  →  [Block 3: items, prev_hash]  →  ...

This gives you a tamper-evident sequence. Each block points back at the one before it via a hash. The whole structure is what gives the name "block chain" its first word and its second.

Step three. Apply what you learned about Merkle trees. Inside each block, the items don't have to be stored as a flat list. They can be summarised by a single Merkle root, also 32 bytes, that commits to every item in the block. The block's header contains just this root plus the previous-block hash plus a few small bits of metadata. The result is a block header that's only around 80 bytes even when the block contains thousands of items.

Step four. Make every party in the network hold a full copy of the chain. Not just a few servers, not a centralised database, but thousands of independent computers each running the same software, each holding the same data, each verifying every new block against the same rules. The picture below shows the same chain replicated across many machines.

This is the second word in "blockchain network." The chain is the data structure. The network is the set of machines that all hold the same copy of it.

Stack these four moves together and look at what falls out.

A shared record exists, because every node holds it.

Tampering with the past is detectable, because each block's hash binds it to the one before, and any change to any historical block invalidates every block after it.

Adding to the present is easy, because anyone running the software can produce a new block that points at the current tip of the chain.

Disagreement can still happen, because two nodes can produce two different new blocks at roughly the same time. The mechanism that decides which one becomes canonical is called consensus, and it gets its own lesson later in this module.

That's a blockchain. A replicated, append-only, hash-linked sequence of blocks, where every node holds the same copy, every block proves the integrity of every previous block, and the structure as a whole is tamper-evident even though no central authority maintains it.

Everything else you'll meet in the rest of this course, transactions, smart contracts, tokens, mining, staking, dApps, NFTs, DeFi, all of it, is what people put inside the items, or what they build on top of the chain once they trust its contents. The chain itself is just the structure described above. Once you see that, the mystery is gone.