Most people who use Bitcoin think of a transaction as an event: you send, it arrives, done. The reality is a choreography of staggering precision. Between the moment you authorise a payment and the moment the network agrees it happened, 82 distinct steps unfold across eleven phases — signing, broadcasting, propagating, assembling, hashing, validating, and finally absorbing the result into a chain that tens of thousands of independent computers all agree on. Nobody directs it. There is no server, no clearing house, no central authority issuing instructions. There is only the protocol, executed in parallel by strangers who trust nothing and verify everything.

Walking the full lifecycle is the single best way to understand what Bitcoin actually is. Not the price. Not the politics. The machine. (The step-by-step breakdown below follows the work of Greg Walker at learnmeabitcoin.com — the finest protocol-level Bitcoin resource on the open internet.) Here is what happens, every ten minutes, while the world sleeps.

Phases 1–3: From Spent Block to Broadcast Transaction

The cycle begins in a state of rest. Block N has been validated and appended to the chain. Every node has updated its UTXO set — the master list of every unspent output, the only thing that actually exists in Bitcoin. There are no account balances; there are only unspent transaction outputs that your keys can unlock. The hash of Block N is now fixed, and it becomes the prev_hash that chains the next block to this one.

Phases 1–3 · Initial State → Transaction Creation → Propagation
1–3Block N validated; all nodes update their UTXO set; its hash becomes the prev_hash for the next block.
4–9Wallet builds a transaction: selects UTXOs as inputs, sets outputs + change, sets the fee, sets nLocktime and sequence (RBF signalling).
10–11Private key signs each input (ECDSA or Schnorr); with SegWit the signature goes in the witness, not the scriptSig.
12–14Transaction serialised; TXID = double-SHA-256 without witness; wTXID = double-SHA-256 with witness.
15Wallet broadcasts to connected nodes.
16–20Each node validates independently (signatures, inputs exist, no double-spend, fee ≥ minimum), adds to its mempool, and floods it to peers — reaching most of the network in seconds.

Notice what has already happened by step 20. A transaction has been created, cryptographically signed, and verified by thousands of independent machines — and not one of them trusted the wallet that created it. Each checked the signatures itself. Each confirmed the inputs existed in its own copy of the UTXO set. Each confirmed the same coins were not being spent twice. The transaction now sits in mempools around the world, agreed upon without anyone being in charge.

Phases 4–5: Building the Candidate

Now a miner goes to work. Not to process your transaction — that is a misconception — but to assemble a candidate block and compete for the right to add it to the chain.

Phases 4–5 · Candidate Block → Header Assembly
21–23Miner selects transactions from the mempool by fee-rate (sat/vB), checks they are jointly valid, fills the block to the weight limit (4,000,000 weight units).
24–25Miner creates the coinbase transaction: subsidy (3.125 BTC) + fees to its own address, with block height + extraNonce + miner tag; coinbase ordered first.
26–28Computes each TXID, builds the Merkle tree by hashing TXIDs pairwise level by level until one 32-byte hash remains: the Merkle root.
29–35Assembles the 80-byte header: version, prev_hash, Merkle root, timestamp, bits (difficulty target), nonce = 0.

The header is now 80 bytes. Those 80 bytes are the entire object that mining operates on. Everything else — the transactions, the coinbase, the Merkle tree — is summarised into the single 32-byte Merkle root inside the header. This is Ralph Merkle’s 1979 invention doing exactly what it was designed to do: compress thousands of transactions into one fingerprint, so that changing any transaction changes the root, which changes the header, which invalidates the work.

Phase 6: Mining — The Thermodynamic Lottery

Here is the heart of it. The miner hashes the 80-byte header and asks one question: is the result smaller than the difficulty target?

Phase 6 · Mining (Proof of Work)
36–37Hash the header: double-SHA-256. Is the result below the target?
38–39No → increment the nonce by 1, hash again.
40–42Nonce range exhausted (4.3 billion tries) → change extraNonce in coinbase → new TXID → new Merkle root → reset nonce, continue.
43–44Optionally update timestamp; the loop runs trillions of times (~6 × 10²³ network-wide per block).
45A miner finds a hash below the target — the block is valid.

This loop — hash, check, increment, repeat — is the most-run computation in human history. It is also profoundly stupid by design. There is no cleverness in it, no shortcut, no strategy. It is brute force: try a number, hash it, check if you won, try the next. The network as a whole performs roughly 6 × 10²³ of these attempts per block — approximately Avogadro’s constant, the number of atoms in 18 grams of water, a single tablespoon.

Every ten minutes, the network performs about as many hash attempts as there are atoms in a tablespoon of water. Almost all of them fail. One succeeds. That is what a block costs.

The stupidity is the point. Because there is no shortcut, the only way to find a valid hash is to actually do the work — spend the electricity, generate the heat, and get lucky. This is the thermodynamic anchor described in Without Proof of Work: the proof cannot be faked because the universe keeps honest accounting of energy spent. The winning miner did not outsmart anyone. They bought more lottery tickets, each one paid for in joules.

Phases 7–9: Propagation, Validation, and Absorption

The moment a miner finds a valid hash, the race flips from computation to communication. The block must reach the network before another miner finds a competing one.

Phases 7–9 · Propagation → Validation → Chain Update
46–49Miner serialises and broadcasts the block; Compact Block Relay (BIP-152) sends mostly header + short IDs since peers already hold the transactions; >90% of nodes in 2–6 seconds.
50–56Each node checks: header syntax, prev_hash points to the current tip, timestamp in range, difficulty correct, hash actually below target, weight ≤ 4,000,000 WU.
57–59Coinbase checks: first and only coinbase, output ≤ subsidy + fees, contains block height (BIP-34).
60–65For every transaction: inputs exist in the UTXO set, signatures valid, no double-spend, inputs ≥ outputs, script conditions met, Merkle root matches.
66–73All checks pass → append Block N+1, update UTXO set, lock coinbase outputs for 100 blocks (maturity), clear confirmed TXs from mempool, relay onward; all miners abandon their old candidates and rebuild on N+1.

Step 73 is the quiet climax of the whole drama. The instant a valid block propagates, every honest miner on Earth — including the ones who were a fraction of a second away from finding their own block — throws away their work and starts again on top of the new block. There is no resentment, no appeal, no committee to petition. The longest valid chain wins, and the network converges on it within seconds. Billions of dollars of mining hardware silently re-points itself at the new tip. This is consensus: not a vote, not a negotiation, but the spontaneous, self-interested alignment of thousands of competitors on a single truth.

Phases 10–11: The Self-Regulating Clock

Two final mechanisms run conditionally, woven into the cycle.

Phases 10–11 · Difficulty Adjustment & Halving
74–79Every 2,016 blocks: measure actual time taken vs. the 20,160-minute target; new target = old target × (actual ÷ 20,160); capped at 4× in either direction.
80–82Every 210,000 blocks: halve the subsidy (3.125 → 1.5625 BTC); every node enforces it independently — a miner writing the old subsidy is simply rejected.

The difficulty adjustment is the network’s thermostat. If mining power surges and blocks arrive too fast, difficulty rises to slow them back to ten minutes; if miners leave and blocks slow, difficulty falls. The ten-minute heartbeat is maintained not by a clock but by a feedback loop, recalibrated every two weeks, forever. The halving is the network’s monetary policy — the algorithmic enforcement of the 21 million cap, executed not by decree but by every node refusing to accept a block that pays the miner too much.

What It Means

The genuinely novel thing here is not digital money, which existed before, but leaderless consensus, which did not. Every other system of comparable scale — a payment network, an air traffic system, a stock exchange — has a central coordinator. Bitcoin has none. The 82 steps are executed independently by every participant, each acting in self-interest, each following the same protocol, each verifying everything and trusting nothing. The agreement emerges. It is not imposed.

And the redundancy is the feature, not the bug. Critics see thousands of nodes all performing the same validation and call it wasteful. They have it backwards: if only one party validated, you would have to trust that party; because every party validates, you have to trust no one. This is where the real power lives — steps 50–66, the validation gauntlet every node runs alone. The 2017 SegWit2x episode proved it: miners with 83% of hashrate could not change the rules because the nodes simply rejected their blocks (the full story is in Without Proof of Work).

Most people who own Bitcoin could not describe what happens between pressing “send” and seeing “confirmed.” That gap is where all the value lives. The person who has walked the 82 steps holds something more durable than coins: the knowledge of why the coins cannot be faked, frozen, or inflated. In a world of narratives, that understanding is the only thing that does not move with the price.

Flight Log — Dispatch from Altitude

Before every flight, I run a checklist. Not because I have forgotten how to fly, but because the checklist does not depend on my memory, my mood, or my confidence on a given morning. It is a sequence of discrete, verifiable steps, executed in a fixed order, each one confirmed before the next begins. Flight controls: checked, free, correct. Fuel: confirmed, quantity cross-checked. Flaps: set. The checklist is a protocol. It converts a complex, high-stakes operation into a series of steps that cannot be skipped and do not require trust in anyone’s judgement — including my own.

The reason aviation is the safest form of mass transport ever created is not that pilots are exceptional. It is that the system does not rely on pilots being exceptional. It relies on protocol — checklists, cross-checks, standard callouts, mandatory verifications — executed the same way, every time, by every crew, regardless of who is in the seat. The genius is in the procedure, not the person.

The lifecycle of a Bitcoin block is a checklist of 82 steps. And like an aviation checklist, its power comes precisely from the fact that it does not depend on trust. No node trusts the miner. No node trusts another node. Each runs the checklist itself — header valid, proof of work valid, coinbase valid, every signature valid, Merkle root matches — and only then accepts the block. In my cockpit, two pilots run the checklist and cross-check each other. In Bitcoin, tens of thousands of nodes run the checklist and cross-check the entire world. The principle is identical: do not trust, verify — step by step, in order, every time.

Every ten minutes, the network completes its checklist and the chain grows by one block. No conductor. No captain. Just the protocol, running while the world sleeps — as reliable as the second law of thermodynamics, and for exactly the same reason.