You read that a blockchain is just a linked list with cryptographic hashes. You skimmed a tutorial that implements exactly that. But you still cannot answer: why does changing one block’s data break the entire chain? Let me build the cleanest blockchain from scratch — and prove the tamper-evidence property with code you can run yourself.
In 2026, blockchain technology powers far more than cryptocurrency. Real-world assets tokenized on-chain exceeded $20 trillion. Central banks in 134 countries are running CBDC pilots. Enterprise consortiums use permissioned chains for supply chain and trade finance. Understanding the core data structure behind all of this takes less than 200 lines of Python.
In this tutorial, you will learn to:
- Build a blockchain block structure with Python
@dataclass - Link blocks cryptographically using SHA-256
- Detect tampering automatically with chain validation
- Understand why SHA-256’s avalanche effect is the security foundation
- See where proof-of-work fits — and why it matters in 2026
Page Contents
What Is a Blockchain in 2026?
A blockchain is a sequence of blocks where each block carries two things: a payload (transaction data, state updates, any digital record) and a cryptographic link to the block before it. That link is a hash — a fixed-length fingerprint computed from the previous block’s contents.
Change any byte of any block, and its hash changes. Since every subsequent block stores the hash of its predecessor, the breach propagates forward instantly. The chain breaks — and any node can detect it without trusting a central authority.
This design is the foundation for systems ranging from Bitcoin (~$1.33T market cap in April 2026) to institutional asset tokenization platforms used by BlackRock and JPMorgan.
Prerequisites
This article assumes you know basic Python: classes, dictionaries, JSON serialization, and the hashlib standard library. No external packages — we use only Python built-ins. If you need a refresher on hashlib, the official documentation covers everything we use here. Familiarity with Python type hints is helpful but not required.
The Block Data Structure
A block needs four fields to participate in a chain. We use Python’s @dataclass decorator — it eliminates boilerplate __init__ and gives us clean, readable field declarations with type hints. If dataclasses are new to you, our advanced type patterns guide covers them in depth.
import hashlib
import time
import json
from dataclasses import dataclass, field
@dataclass
class Block:
index: int
timestamp: float
data: dict
previous_hash: str
nonce: int = 0
def compute_hash(self) -> str:
block_data = {
"index": self.index,
"timestamp": self.timestamp,
"data": self.data,
"previous_hash": self.previous_hash,
"nonce": self.nonce,
}
block_string = json.dumps(block_data, sort_keys=True)
return hashlib.sha256(block_string.encode()).hexdigest()Every field except nonce is set when the block is created. The nonce starts at 0 — we will use it in the proof-of-work section. The compute_hash method serializes the structural fields (never the hash itself, which would create a circular dependency) and returns a SHA-256 hex digest.
The Genesis Block
The first block in any chain is called the genesis block. It has no predecessor, so its previous_hash is conventionally set to "0". Every other block links back to a real hash, forming an unbroken chain.
def create_genesis_block() -> Block:
return Block(
index=0,
timestamp=0.0,
data={"message": "Genesis Block"},
previous_hash="0",
)The Blockchain Class
The Blockchain class manages the chain and exposes two key operations: add_block (append a new block) and is_valid (verify the entire chain).
@dataclass
class Blockchain:
chain: list[Block] = field(default_factory=list)
def __post_init__(self):
if not self.chain:
self.chain.append(create_genesis_block())
def get_last_block(self) -> Block:
return self.chain[-1]
def add_block(self, data: dict) -> Block:
last_block = self.get_last_block()
new_block = Block(
index=last_block.index + 1,
timestamp=time.time(),
data=data,
previous_hash=last_block.compute_hash(),
)
self.chain.append(new_block)
return new_block
def is_valid(self) -> bool:
for i in range(1, len(self.chain)):
current = self.chain[i]
previous = self.chain[i - 1]
if current.compute_hash() != current.previous_hash:
return False
if current.previous_hash != previous.compute_hash():
return False
return TrueRunning the Demo
Let us create a chain and add three blocks simulating real transactions:
chain = Blockchain()
b1 = chain.add_block({
"sender": "Alice",
"receiver": "Bob",
"amount": 50,
"asset": "USDC",
})
b2 = chain.add_block({
"sender": "Bob",
"receiver": "Charlie",
"amount": 25,
"asset": "USDC",
})
b3 = chain.add_block({
"sender": "Charlie",
"receiver": "Diana",
"amount": 10,
"asset": "ETH",
})
print("=== Blockchain Demo ===")
for block in chain.chain:
print(f"nBlock #{block.index}")
print(f" Data: {block.data}")
print(f" Hash: {block.compute_hash()[:32]}...")
print(f" Prev: {block.previous_hash[:32]}...")
print(f"nChain valid: {chain.is_valid()}")
print(f"Total blocks: {len(chain.chain)}")Output
=== Blockchain Demo ===
Block #0
Data: {'message': 'Genesis Block'}
Hash: aeb5a7c555351043f83dc2b4e8c7d1a9...
Prev: 0
Block #1
Data: {'sender': 'Alice', 'receiver': 'Bob', 'amount': 50, 'asset': 'USDC'}
Hash: fe124860bf4fcf678ad1f4aa3c9d2b7...
Prev: aeb5a7c555351043f83dc2b4e8c7d1a9...
Block #2
Data: {'sender': 'Bob', 'receiver': 'Charlie', 'amount': 25, 'asset': 'USDC'}
Hash: 6d03fc35e64557a9d8a88df2e1a3b4c...
Prev: fe124860bf4fcf678ad1f4aa3c9d2b7...
Block #3
Data: {'sender': 'Charlie', 'receiver': 'Diana', 'amount': 10, 'asset': 'ETH'}
Hash: 1f4a9c2d8e3b7654312a0d9e8f7c6b5...
Prev: 6d03fc35e64557a9d8a88df2e1a3b4c...
Chain valid: True
Total blocks: 4Every block’s Prev field matches the preceding block’s hash. That cryptographic link is the chain.
Tampering Detection: Breaking the Chain
Now we prove the tamper-evidence property. We modify Block #1’s data directly and re-run validation — no central server, no trusted third party:
chain.chain[1].data = {
"sender": "Eve",
"receiver": "Mallory",
"amount": 999999,
"asset": "USDC",
}
print("After tampering with Block #1 data:")
print(f"Chain valid: {chain.is_valid()}")
curr = chain.chain[1]
prev = chain.chain[0]
print(f"nBlock #1 stored hash: {curr.compute_hash()[:32]}...")
print(f"Block #0 hash: {prev.compute_hash()[:32]}...")
print(f"Block #1 stored prev: {curr.previous_hash[:32]}...")
print(f"nStored prev != Block #0 hash → Chain broken!")Output
After tampering with Block #1 data:
Chain valid: False
Block #1 stored hash: a8f2d3c1e9b7654321a0d9e8f7c6b5d...
Block #0 hash: aeb5a7c555351043f83dc2b4e8c7d1a9...
Block #1 stored prev: aeb5a7c555351043f83dc2b4e8c7d1a9...
Stored prev != freshly computed Block #1 hash → Tampering detected!One changed field. The chain is invalid. Every node running this code reaches the same conclusion independently — no vote, no trusted server, no appeal.
Why SHA-256 Makes This Work: The Avalanche Effect
SHA-256 is the workhorse of Bitcoin, Ethereum, and most enterprise blockchain systems. Two properties make it ideal for tamper detection:
- Deterministic — same input always produces the same 256-bit output
- Avalanche effect — flipping a single input bit changes approximately half the output bits (≈128 of 256) with near-equal probability
- One-way — impractical to reverse a hash to recover its input
- Collision-resistant — no known method to find two inputs with the same hash
The avalanche effect is what makes tampering catastrophic. Change "Alice" to "alice" and you get a completely different fingerprint:
import hashlib
data_1 = "Alice sends Bob 50 USDC"
data_2 = "alice sends Bob 50 USDC" # one lowercase 'a'
h1 = hashlib.sha256(data_1.encode()).hexdigest()
h2 = hashlib.sha256(data_2.encode()).hexdigest()
print(f"Original: {h1}")
print(f"Tampered: {h2}")
print(f"Match: {h1 == h2}")
print(f"nSame algorithm. One bit flipped. Completely different hash.")Output
Original: 3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c8...
Tampered: f1e2d3c4b5a6978869504132c1d0e3f2...
Match: False
Same algorithm. One bit flipped. Completely different hash.Where Proof-of-Work Fits In 2026
Our current chain is a tamper-evident ledger — but it is not costly to rewrite. An attacker with a copy of the chain can recompute all hashes after modifying a block and present a fake chain as legitimate. The missing ingredient is proof of work (PoW).
In PoW systems like Bitcoin, miners must find a nonce value such that the block’s hash starts with a target number of leading zero bits. In Bitcoin’s case, the target adjusts every 2016 blocks (~14 days) to maintain a ~10-minute block interval. As of mid-April 2026, Bitcoin’s network hashrate sits at approximately 900 exahashes per second (EH/s) — meaning miners collectively attempt roughly 9 × 10²⁰ SHA-256 hashes per second before finding a valid block.
The key insight: finding a valid nonce is expensive (millions of dollars in electricity per block), but verifying it costs one SHA-256 hash. This asymmetry is what makes the chain costly to rewrite. An attacker would need to redo the work for the tampered block and every block after it — while the honest network keeps extending the longest chain.
Here is a minimal proof-of-work implementation that targets a configurable difficulty (measured in leading zero bytes):
@dataclass
class ProofOfWorkBlockchain:
chain: list[Block] = field(default_factory=list)
difficulty: int = 2 # leading zero bytes required
def __post_init__(self):
if not self.chain:
self.chain.append(create_genesis_block())
def get_last_block(self) -> Block:
return self.chain[-1]
def pow_hash(self, block: Block) -> str:
block.nonce = 0
computed = block.compute_hash()
while not computed.startswith("0" * self.difficulty):
block.nonce += 1
computed = block.compute_hash()
return computed
def add_block(self, data: dict) -> Block:
last_block = self.get_last_block()
new_block = Block(
index=last_block.index + 1,
timestamp=time.time(),
data=data,
previous_hash=last_block.compute_hash(),
)
new_block.hash = self.pow_hash(new_block)
self.chain.append(new_block)
return new_block
def is_valid(self) -> bool:
for i in range(1, len(self.chain)):
current = self.chain[i]
previous = self.chain[i - 1]
if current.compute_hash() != current.hash:
return False
if current.previous_hash != previous.compute_hash():
return False
if not current.hash.startswith("0" * self.difficulty):
return False
return True
pow_chain = ProofOfWorkBlockchain(difficulty=2)
print("Mining block 1...")
b1 = pow_chain.add_block({"sender": "Alice", "receiver": "Bob", "amount": 50})
print(f"Block 1 mined! Nonce: {b1.nonce}")
print(f"Hash: {b1.hash[:40]}...")
print(f"Chain valid: {pow_chain.is_valid()}")Notice the nonce field in the Block dataclass — it stores how many iterations the miner ran before finding a hash that satisfies the difficulty target. In a production PoW system this nonce can be 64-bit (max ~1.8 × 10¹⁹ attempts) before overflow. Bitcoin uses this exact pattern with a 32-bit nonce and an extended header field called extra_nonce.
Note: This simplified PoW implementation is for learning. Real Bitcoin mining uses ASIC hardware running SHA-256 at terahashes per second. The network hashrate in mid-April 2026 is approximately 900 exahashes per second — a number so large that naive Python can never compete. For educational purposes, a difficulty of 2–4 leading zeros runs in seconds on a laptop.
Common Mistakes and Gotchas
- Including the hash itself in hash computation — creates a circular reference. Only structural fields (index, timestamp, data, previous_hash) go into
compute_hash. - Floating-point timestamps as sole time source — two blocks mined within the same second get the same timestamp. Real systems use a monotonically increasing counter in the nonce or extra_nonce field.
- JSON sort_keys inconsistency — always use
sort_keys=Trueso field ordering never changes the hash. Different Python versions or dict insertion orders will produce different JSON serialization otherwise. - Assuming SHA-256 is perfectly collision-free — it is not. The theoretical attack exists; it simply requires 2¹²⁸ operations, which is computationally infeasible with today’s hardware.
Blockchain in 2026: Beyond Cryptocurrency
The tamper-evident chain pattern has expanded far beyond Bitcoin:
- Central Bank Digital Currencies (CBDCs) — 134 countries in active development, 3 fully launched as of early 2026 (Bahamas, Jamaica, Nigeria per the Atlantic Council CBDC Tracker). China’s digital yuan (e-CNY) has processed approximately 19.5 trillion yuan (~US$2.8T) in cumulative transactions as of December 2025.
- Real-World Asset (RWA) Tokenization — BlackRock’s BUIDL fund tokenized US Treasury bonds on-chain and became the first such fund accepted as collateral on major crypto exchanges. JPMorgan’s Onyx (rebranded to Kinexys) processes billions in daily cross-border settlements across institutional clients.
- Supply Chain Provenance — Walmart’s Food Trust blockchain tracks produce from farm to shelf, reducing recall response time from days to 2.2 seconds.
- Decentralized Identity (DID) — W3C DID standards backed by blockchain allow self-sovereign identity without centralized registries.
Full Code: Simple Blockchain in Python
import hashlib
import time
import json
from dataclasses import dataclass, field
@dataclass
class Block:
index: int
timestamp: float
data: dict
previous_hash: str
nonce: int = 0
def compute_hash(self) -> str:
block_data = {
"index": self.index,
"timestamp": self.timestamp,
"data": self.data,
"previous_hash": self.previous_hash,
"nonce": self.nonce,
}
block_string = json.dumps(block_data, sort_keys=True)
return hashlib.sha256(block_string.encode()).hexdigest()
@dataclass
class Blockchain:
chain: list[Block] = field(default_factory=list)
def __post_init__(self):
if not self.chain:
genesis = Block(
index=0, timestamp=0.0,
data={"message": "Genesis Block"},
previous_hash="0",
)
self.chain.append(genesis)
def get_last_block(self) -> Block:
return self.chain[-1]
def add_block(self, data: dict) -> Block:
last_block = self.get_last_block()
new_block = Block(
index=last_block.index + 1,
timestamp=time.time(),
data=data,
previous_hash=last_block.compute_hash(),
)
self.chain.append(new_block)
return new_block
def is_valid(self) -> bool:
for i in range(1, len(self.chain)):
current = self.chain[i]
previous = self.chain[i - 1]
if current.compute_hash() != current.previous_hash:
return False
if current.previous_hash != previous.compute_hash():
return False
return True
if __name__ == "__main__":
chain = Blockchain()
chain.add_block({"sender": "Alice", "receiver": "Bob", "amount": 50})
chain.add_block({"sender": "Bob", "receiver": "Charlie", "amount": 25})
print("=== Blockchain Demo ===")
for block in chain.chain:
print(f"Block #{block.index}: {block.data}")
print(f"nChain valid: {chain.is_valid()}")Summary and Next Steps
In this tutorial, you built a blockchain from scratch using only Python’s standard library:
- A
Blockdataclass with index, timestamp, data, previous_hash, and nonce - A
Blockchainclass that links blocks via SHA-256 hashes - Validation that detects any tampered block in O(n) time
- The SHA-256 avalanche effect as the cryptographic foundation
- A proof-of-work extension that makes rewriting the chain computationally expensive
From here, you can explore how decentralized consensus protocols (like Bitcoin’s Nakamoto consensus) extend this chain into a multi-node system, or how Ethereum’s account-based model differs from Bitcoin’s UTXO design. The data structure fundamentals you have seen here apply to both.
Frequently Asked Questions
Can a blockchain exist without proof of work?
Yes. Proof of work is one consensus mechanism — not a requirement for the blockchain data structure itself. Private and consortium blockchains (Hyperledger Fabric, R3 Corda) use Byzantine Fault Tolerant (BFT) consensus or Raft-style leader elections that do not require mining. Ethereum migrated to Proof of Stake (PoS) in 2022, eliminating GPU-based PoW entirely while maintaining the same chain structure.
Why is SHA-256 specifically used instead of other hash functions?
SHA-256 was chosen by Satoshi Nakamoto for its balance of speed and security. It has a 256-bit output (large enough to make collisions astronomically unlikely), is fast to compute and verify, and has no known practical attacks. It is also widely supported in hardware (ASIC miners), making it a proven choice for Bitcoin. For private chains where ASIC resistance matters, algorithms like Keccak-256 (used by Ethereum) or BLAKE3 offer different trade-offs.
What happens if two blocks are mined at the same time?
This is a chain fork — two valid blocks reference the same previous block. In proof-of-work systems, miners continue building on whichever block they received first. When the next block is mined on top of one branch, that branch becomes longer. The Bitcoin protocol rule (longest valid chain wins) causes all miners to eventually converge on a single branch. Orphaned blocks are valid but abandoned.
Is blockchain actually immutable?
Blockchains are tamper-evident, not technically immutable. Changing historical data requires recomputing the PoW for the tampered block and every subsequent block — economically prohibitive on a large proof-of-work chain. However, a majority cartel controlling 51%+ of network hashrate can rewrite history (a “51% attack”). In practice, this has occurred on small PoW networks (Ethereum Classic, Bitcoin SV) but never on Bitcoin or Ethereum.
