How Bitcoin Works

San Francisco, March 2011.

James Sullivan sits in his apartment, staring at his computer screen. He’s been running Bitcoin for over two years now. Mining occasionally. Making a few transactions. Accumulating coins that are now worth about one dollar each.

But he doesn’t fully understand how it works. Not really. He’s read Satoshi’s paper multiple times. He’s read forum discussions. He’s talked to other people running the software. But there’s a gap between reading about something and understanding it deeply enough to trust it.

And trust is the question that keeps bothering him.

In traditional finance, trust is institutional. You trust the bank to keep accurate records. You trust the government to prevent counterfeiting. You trust the Federal Reserve to manage the currency. The system works because institutions are trustworthy, or at least powerful enough to enforce their version of truth.

Bitcoin claims to eliminate trust. To replace institutions with mathematics. To make verification possible for anyone, anywhere.

James decides to test this claim. Not by reading more papers. By actually verifying. Running every check he can think of. Making sure the system works the way Satoshi described.

He downloads fresh software. Clears his old blockchain data. Starts from scratch.

The software begins syncing. Downloading every transaction since the genesis block in January 2009. Over two years of history. Hundreds of thousands of transactions. Every block. Every proof of work. Everything.

His computer verifies each one.

This is going to take a while.

The Blockchain

James watches the progress bar. Block 1. Block 2. Block 3. The software is downloading and verifying every block ever created.

But why download everything? In a normal system, the bank keeps the records. You just check your balance. Here, there was no bank. So who kept the records?

Everyone. Everyone who ran the software. They all had the same history. The same ledger. Every transaction ever made.

James opens the data directory. Looks at the files. Raw blocks. Thousands of them. Each one containing hundreds of transactions. Each block linked to the previous block. Block 1 linked to block 0 (the genesis block). Block 2 linked to block 1. Block 3 linked to block 2. An unbroken chain back to the beginning.

That’s why they called it a blockchain.

He studies the structure. Each block contains:

• A reference to the previous block
• A timestamp
• A list of transactions
• A proof-of-work solution

The reference to the previous block is what creates the chain. Block 50 points to block 49. Block 49 points to block 48. Block 48 points to block 47. All the way back to the genesis block. You can’t insert a fake block in the middle. You can’t change history. Because every block that comes after references the blocks that came before.

If you tried to change a transaction in block 1000, you’d have to recalculate the proof-of-work for block 1000. But then block 1001’s reference wouldn’t match anymore. So you’d have to recalculate block 1001. And block 1002. And block 1003. Every block that came after. All the way to the present.

You’d have to redo years of computational work. While everyone else is adding new blocks. You’d never catch up. The honest chain would always be longer. And the network accepts the longest chain as truth.

That’s how Bitcoin prevents rewriting history. Not through authority. Through work. Computational work that’s expensive to produce and easy to verify.

James found this elegant. The blockchain wasn’t just a database. It was a database protected by the laws of physics.

Possible in theory. Prohibitively expensive in practice.

But he wanted to verify this himself. Not just understand conceptually. Actually check.

He decided to trace a single bitcoin through the blockchain. From creation to the present. Make sure the system actually prevented double-spending.

Following the Money

James picked a random transaction from block 5000. Someone sending 10 bitcoins to someone else.

He checked: did the sender actually have 10 bitcoins to send? He traced backward. Found where those 10 bitcoins came from. Another transaction. Someone sent them 10 bitcoins in block 4850.

Did that sender have 10 bitcoins? James traced further back. Block 4200. Someone sent them 10 bitcoins.

Where did those come from? Block 3800. Mining reward. Someone solved a proof-of-work puzzle and received 50 newly created bitcoins. They later sent 10 of those to the next person.

James followed the chain all the way back. Every bitcoin he examined could be traced to a mining reward. Coins created by proof-of-work. Then transferred from person to person through valid transactions.

No coins appeared from nothing. No one spent coins they didn’t have. Every transaction was verified by the network. Every block confirmed those transactions.

The system worked exactly as described. You couldn’t counterfeit bitcoins because every coin’s history was public and verifiable. You couldn’t double-spend because once you sent coins, that transaction was recorded in the blockchain. If you tried to send the same coins again, the network would see you didn’t have them anymore and reject the transaction.

James tried something else. He looked for examples of attempted fraud. Did anyone try to double-spend? Try to send coins they didn’t have?

He found several attempts in the early blocks. Someone would broadcast two transactions spending the same coins. Two different recipients. Which one was valid?

The network solved this through mining. Whichever transaction got included in a block first was the valid one. The other was rejected. Miners wouldn’t include the second transaction in future blocks because it would make those blocks invalid.

So you couldn’t double-spend. Not because someone was watching and preventing it. Because the math didn’t work. The network reached consensus about transaction order. First one in the blockchain was valid. Later ones spending the same coins were invalid. Simple. Automatic. Mathematical.

James spent hours tracing transactions. Checking signatures. Verifying proofs.

Everything checked out. The system was exactly as trustless as claimed.

You didn’t need to trust the sender. Didn’t need to trust miners. Didn’t need to trust anyone. You could verify everything yourself.

But he still didn’t fully understand how mining worked.

How did the network decide which transactions were valid? How did miners create new blocks? What made proof-of-work expensive?

Time to dig deeper.

Mining

James looked at the mining process more carefully.

Here’s what miners actually do:

They collect pending transactions. People broadcasting Bitcoin payments. Those transactions sit in a “mempool”: a waiting area. Unconfirmed. Not yet part of the blockchain.

A miner takes transactions from the mempool. Bundles them into a candidate block. Maybe 500 transactions. Maybe 2,000. Whatever fits.

Then the miner tries to solve a puzzle. Find a number, called a “nonce,” that makes the block’s hash meet certain requirements. Specifically, the hash has to start with a certain number of zeros.

The hash function is one-way. You put in a block of data, you get out a string of letters and numbers. Looks random. The only way to find a nonce that produces a hash starting with, say, ten zeros is to try different numbers until you find one that works.

Try nonce 1. Hash the block. Doesn’t start with ten zeros. Try nonce 2. Hash again. Still doesn’t work. Try nonce 3. Nonce 4. Nonce 5. Millions of attempts. Billions of attempts.

Eventually, someone finds a nonce that works. They broadcast the block to the network. Everyone verifies it instantly: just hash the block once and check if it starts with enough zeros. It does. The block is valid. Add it to the blockchain.

The successful miner receives a reward. When Satoshi launched Bitcoin, the reward was 50 bitcoins per block. Every four years, it cuts in half. 50, then 25, then 12.5, then 6.25. Eventually approaching zero. The total supply caps at 21 million bitcoins.

This is how new bitcoins are created. Through mining. Through proof-of-work. Through expending real computational power and electricity.

James understood why this mattered. Creating bitcoins required work. Real work. Measurable work. You couldn’t just declare more bitcoins into existence. You had to mine them. And mining got progressively harder as more people participated.

The network adjusted the puzzle difficulty every 2,016 blocks, about two weeks. If blocks were being found faster than every ten minutes, the difficulty increased. Required more zeros in the hash. Made the puzzle harder. If blocks were coming slower than every ten minutes, difficulty decreased.

This kept block production steady. One block every ten minutes, on average, no matter how many miners participated. No matter how much computational power was pointed at Bitcoin.

James checked the difficulty history. In 2009, when Satoshi was mining alone, difficulty was 1. You could mine blocks on a laptop. By 2011, difficulty was over 100,000. Mining required specialized hardware. The more valuable Bitcoin became, the more people mined. The harder the puzzles became. A self-regulating system.

And here was the key insight: to attack Bitcoin, to rewrite the blockchain, you’d need to redo all that work. You’d need more computational power than all the honest miners combined. You’d need to mine faster than the rest of the network to create a longer chain.

The cost to attack Bitcoin was directly proportional to the amount of honest mining happening. As Bitcoin grew, as more miners joined, as more hardware was dedicated to securing the network, attacks became more expensive.

Not impossible. Just expensive. And getting more expensive every day.

James ran the numbers. In early 2011, Bitcoin’s total mining power was substantial. To attack it, you’d need to spend millions on hardware and electricity. For what? To double-spend your own coins? To destroy confidence in Bitcoin? The cost outweighed any rational benefit.

This is what made Bitcoin secure. Not armies. Not laws. Not institutions. Economics. Mathematics. The simple fact that attacking the network cost more than you’d gain from succeeding.

The Network

James had verified individual transactions. Understood how mining worked. But one question remained: how did the network stay coordinated? How did thousands of computers around the world all agree on the same blockchain without anyone in charge?

He studied the networking code. How Bitcoin propagated information. How nodes communicated.

Here’s what he found:

When someone makes a transaction, they broadcast it to nearby nodes. Those nodes verify the transaction: check that the sender has the coins, that the signature is valid, that everything is mathematically correct. If valid, they broadcast it to their nearby nodes. And so on. Within seconds, the transaction has spread across the entire network.

Same with blocks. When a miner solves a proof-of-work puzzle, they broadcast the new block. Nodes verify it: check that all transactions are valid, that the proof-of-work is correct, that the block properly references the previous block. If valid, they add it to their blockchain and broadcast it to other nodes.

Sometimes two miners find valid blocks at almost the same time. Two different blocks, both building on the same previous block. The network temporarily splits. Some nodes hear about block A first. Some hear about block B first.

Which one is correct?

Both are correct. Temporarily. The network waits to see which chain gets longer. Miners continue working. One chain gets the next block first. That becomes the longer chain. The shorter chain is abandoned. Transactions from the orphaned block go back into the mempool to be included in future blocks.

This is how the network reaches consensus. Not through voting. Not through authority. Through proof-of-work. The longest chain, the chain with the most computational work, behind it. is accepted as truth.

James found this remarkable. Thousands of computers. No central coordinator. No authority. Yet they all agreed on the same history. The same sequence of transactions. The same blockchain.

And anyone could join. Anyone could run a node. Anyone could verify the entire history themselves. You didn’t need permission. Didn’t need to register. Didn’t need approval from anyone.

James thought about traditional systems. Banks had central databases. Someone controlled access. Someone decided who could participate. Someone could shut it down. Governments could force changes. Regulators could impose rules.

Bitcoin had none of that. The code was open source. Anyone could read it. Anyone could run it. Anyone could propose changes, but changes only happened if the majority of the network agreed. No one controlled it. Not miners. Not developers. Not early adopters. Not even Satoshi.

The network ran on consensus. Economic incentives kept everyone honest. Mathematics ensured security. And the whole system worked without any central point of control.

This was what decentralization actually meant. Not just “no company.” Not just “no single server.” No one in control at all. No one who could be pressured, regulated, arrested, or coerced. No single point of failure.

You couldn’t arrest the CEO. There was no CEO. You couldn’t seize the servers. There were no central servers. The network was distributed across thousands of computers in dozens of countries. To shut it down, you’d have to shut down the internet itself.

James understood now why Satoshi disappeared. If Satoshi had stayed, governments could target them. Force changes to the protocol. Shut down development. But with Satoshi gone, there was no one to target. Bitcoin was truly leaderless. Truly permissionless. Truly unstoppable.

The Supply Cap

One more thing bothered James. The 21 million cap. Bitcoin’s code said only 21 million bitcoins would ever be created. But code could be changed. Software could be updated. What prevented someone from changing the code to create more bitcoins?

He studied how the supply schedule worked.

Block rewards started at 50 bitcoins. Every 210,000 blocks, roughly every four years, the reward halved. 50 became 25. Then 12.5. Then 6.25. Then 3.125. The halvings continued until the reward became so small it rounded to zero.

The mathematics were precise. Add up all the rewards: 50 × 210,000 + 25 × 210,000 + 12.5 × 210,000 + … = approximately 21 million bitcoins. A fixed supply. Predetermined. Decreasing over time until no new coins were created.

After all coins were mined, miners would be paid through transaction fees instead of block rewards. People would pay small fees to have their transactions included in blocks. Miners would collect those fees. The system would continue working.

But what prevented changing the supply cap? What if miners decided to increase the rewards? What if they voted to create more bitcoins?

James thought through the incentives. Miners were paid in bitcoin. If they inflated the supply, they’d devalue their own earnings. They had no incentive to inflate.

But more fundamentally: changing the supply cap required changing the protocol. Every node ran software that verified blocks. That software checked that block rewards followed the halving schedule. If a miner created a block with a larger reward than allowed, other nodes would reject it. The block wouldn’t be added to the blockchain.

To inflate Bitcoin’s supply, you’d need to change the code. Then convince the majority of the network to run your new code. Then create blocks following the new rules.

But if you changed the rules, you’d create a separate currency. A fork. People running the old code would continue with 21 million cap. People running new code would have a different cap. Two separate blockchains. Two separate coins.

Which one was Bitcoin? The one that followed the original rules. The one that maintained the 21 million cap. Because that’s what people agreed Bitcoin was.

James saw the brilliance. The supply cap wasn’t enforced by authority. It was enforced by consensus. By every node running software that rejected inflation. You could try to create more bitcoins, but the network wouldn’t accept them. Your inflated blocks would be ignored. Your version would be rejected.

The 21 million cap was guaranteed not by law, but by mathematics and economics. By verification and consensus. By thousands of people running software that enforced the rules.

This was fundamentally different from traditional money. The Federal Reserve could create dollars at will. No mathematical constraint. No algorithmic enforcement. Just decisions by people in a room. If they wanted to print more, they printed more.

Bitcoin couldn’t be inflated. Not because Satoshi said so. Not because some authority prevented it. Because the mathematics said so. Because the network enforced the rules. Because changing them required consensus that would never come.

Scarce by design. Sound money, digitally.

The Realization

James had spent three weeks verifying. Reading code. Running the software. Testing the system. Tracing transactions. Understanding mining. Checking consensus. Confirming the supply cap.

Everything worked exactly as Satoshi’s paper described. The blockchain prevented double-spending. Mining made attacks prohibitively expensive. The network achieved consensus without central authority. The 21 million cap was mathematically guaranteed. No one controlled it. No one could change it. No one could shut it down.

Bitcoin was real. It worked. And it was everything the cypherpunks had been trying to build for twenty years.

But James was still a skeptic at heart. Still someone who worked in traditional finance. Still someone who’d spent his career understanding how the old system functioned.

So he asked himself the question that mattered most: Why does this actually matter?

It was clever, sure. Elegant design. Impressive engineering. Beautiful mathematics. But so what? The dollar worked. Banks worked. The financial system, despite its flaws, functioned. Credit cards processed billions of transactions. Wire transfers moved trillions of dollars. PayPal, Venmo, payment apps. All worked fine for most people.

Why would anyone need an alternative?

The answer hit him while he was reading about the genesis block again. The message Satoshi had embedded: “Chancellor on brink of second bailout for banks.”

Bitcoin wasn’t just technology. It was a statement. An alternative. An escape route.

For people like Rebecca Chen, who’d lost everything when the system failed and the banks got bailed out. For people like Dorothy Martinez, whose savings had been quietly stolen by inflation while governments printed money without constraint. For people living under authoritarian governments who controlled banking and surveilled transactions. For people excluded from the financial system entirely. For anyone who wanted to store and transfer value without asking permission from banks or governments.

Bitcoin gave them an option.

And options changed everything. When you had no alternative, you had no leverage. You accepted whatever the system offered because you had no choice. But when alternatives existed, when you could opt out, when you could choose a different system entirely, power shifted.

Banks couldn’t inflate Bitcoin. Governments couldn’t freeze Bitcoin. Payment processors couldn’t block Bitcoin. Institutions couldn’t control Bitcoin. Because Bitcoin needed no institutions. It ran on mathematics, cryptography, and distributed consensus.

James had verified this personally. Spent three weeks testing every claim. Everything Satoshi said was true. Bitcoin worked. It was secure. It was decentralized. It was unstoppable.

For the first time in his adult life, James felt something unfamiliar: hope.

Not naive hope. Not wishful thinking. Grounded hope. Hope based on verification. On mathematics. On systems that worked not because someone promised they would, but because the code said they must.

After twenty years of watching the financial system from inside, seeing how it actually worked, understanding its corruption and control, James now saw an alternative. Not perfect. Not complete. But real. Functioning. Growing.

Bitcoin had freed money from government control. Proven that alternatives were possible. Demonstrated that mathematics could replace institutions.

The question now was: would this actually matter? Would Bitcoin grow beyond a small community of enthusiasts? Would ordinary people use it? Would it change anything?

James didn’t know. But he knew one thing: Bitcoin worked. The code was sound. The system was secure. The incentives aligned. The mathematics guaranteed it.

Everything else was just adoption. Just time. Just people discovering that they had options they didn’t have before.

And that discovery was about to change the world.