Build Your Own Blockchain

Step 1 — A block and its fingerprint

A block holds some data (transactions), a link to the previous block, and a "nonce" (a number we can change). Its identity is a SHA-256 hash of all its contents — change one character and the hash changes completely. That hash is the block’s tamper-evident fingerprint.

import hashlib, json, time

class Block:
    def __init__(self, index, transactions, previous_hash, nonce=0):
        self.index = index
        self.timestamp = time.time()
        self.transactions = transactions
        self.previous_hash = previous_hash
        self.nonce = nonce

    def hash(self):
        # A block's fingerprint = SHA-256 of all its contents.
        payload = json.dumps({
            "index": self.index,
            "timestamp": self.timestamp,
            "transactions": self.transactions,
            "previous_hash": self.previous_hash,
            "nonce": self.nonce,
        }, sort_keys=True).encode()
        return hashlib.sha256(payload).hexdigest()

Step 2 — Mining (Proof of Work)

Mining means finding a hash that meets a rule — here, starting with a set number of zeros. There is no formula; you brute-force the nonce until the hash fits. Checking a solution is instant, but finding one takes work. That asymmetry is the heart of Proof of Work.

DIFFICULTY = 4  # require this many leading zeros

def mine(block):
    # Proof of Work: keep changing the nonce until the hash
    # starts with DIFFICULTY zeros. There is no shortcut —
    # you just have to guess, which is what costs energy.
    target = "0" * DIFFICULTY
    while not block.hash().startswith(target):
        block.nonce += 1
    return block.hash()

Step 3 — Chaining the blocks

Each new block stores the hash of the previous one, welding them into a chain that starts with a hard-coded "genesis" block. Because every block commits to the one before it, the order is fixed and the history is linked together.

class Blockchain:
    def __init__(self):
        # The genesis block — the very first, hard-coded block.
        genesis = Block(0, [{"note": "genesis"}], "0")
        mine(genesis)
        self.chain = [genesis]

    def add_block(self, transactions):
        prev = self.chain[-1]
        block = Block(len(self.chain), transactions, prev.hash())
        mine(block)            # do the work
        self.chain.append(block)
        return block

Step 4 — Validating the chain

To trust a chain, you re-check it: every block must point to the real hash of the previous block, and every block must satisfy the proof-of-work rule. If either check fails anywhere, the chain is invalid.

def is_valid(chain):
    for i in range(1, len(chain)):
        current, previous = chain[i], chain[i - 1]
        # 1) Each block must point to the real hash of the one before it.
        if current.previous_hash != previous.hash():
            return False
        # 2) Each block must satisfy the proof-of-work rule.
        if not current.hash().startswith("0" * DIFFICULTY):
            return False
    return True

Step 5 — Run it and try to cheat

Now add a few blocks and then tamper with an old transaction. The moment you change past data, that block’s hash no longer matches what the next block expects — and validation instantly returns False. This is, in miniature, why you cannot quietly rewrite Bitcoin’s history.

bc = Blockchain()
bc.add_block([{"from": "Alice", "to": "Bob", "amount": 5}])
bc.add_block([{"from": "Bob", "to": "Carol", "amount": 2}])

print("Chain valid?", is_valid(bc.chain))   # True

# Now try to cheat: tamper with an old transaction.
bc.chain[1].transactions[0]["amount"] = 5000
print("Chain valid?", is_valid(bc.chain))   # False — tampering is caught!

What real Bitcoin adds

Our toy chain teaches the skeleton. Real Bitcoin adds a global peer-to-peer network of nodes, digital signatures that prove who can spend coins, automatic difficulty adjustment, the UTXO model, block rewards and halvings, and the consensus rules that let strangers agree without trust. Explore each in our explainers below.

Frequently asked questions

Keep learning