The Code Most People Never See
Yeah,yeah i know more than 90% of the people reading this have heard of bitcoin. Everyone talks about Bitcoin's price. Few people talk about what makes it actually work. Under the hood, Bitcoin is a marvel of applied cryptography, distributed systems, and elegant scripting and you don't need to be a cryptographer to understand it.
01 Transactions
How a transaction is born
When you send Bitcoin, your wallet doesn't move coins the way a bank does. Instead, it constructs a raw transaction, a small blob of binary data referencing previous unspent outputs (UTXOs) as inputs, and specifying new outputs for the recipient and change.
That transaction is then broadcast to the peer-to-peer network using Bitcoin's gossip protocol. Every node that receives it validates the transaction independently, then forwards it to its peers, no central server involved.
# Ask your local node what chain it's on
bitcoin-cli getblockchaininfo
# Create a fresh receiving address
bitcoin-cli getnewaddress "savings"
# Send 0.001 BTC to an address
bitcoin-cli sendtoaddress "bc1q..." 0.001
02 Validation
What nodes actually check
What nodes actually check
Every full node runs the same checklist before accepting a transaction into its mempool:
- Does each referenced UTXO exist and is it unspent?
- Do inputs sum to at least as much as outputs (accounting for the fee)? much as outputs (accounting for the fee)?
- Is the cryptographic signature valid for each input?
- Does the unlocking script satisfy the locking script on the UTXO?
No trusted third party decides. The rules are in the code, and every node enforces them equally.
03 Cryptography
The signature that proves ownership
Bitcoin uses secp256k1 elliptic-curve cryptography. Your private key is a 256-bit secret number. Your public key and ultimately your address is derived from it mathematically, but the reverse is computationally infeasible.
To spend a UTXO, you prove you know the private key by producing a digital signature over the transaction data. The network verifies the signature using only your public key, your secret never leaves your wallet.
This is why "not your keys, not your coins" is more than a slogan. Without the private key, the signature cannot be produced and the output cannot be spent.
04 Mining
How blocks get added
Miners collect pending transactions from the mempool, assemble them into a block candidate, and then compete to find a special number the nonce such that the block's SHA-256 hash starts with enough leading zeros to meet the current difficulty target.
# The block header includes:
{
"previousblockhash": "00000000000...",
"merkleroot": "e3b0c44298fc...",
"nonce": 2083236893,
"bits": "1d00ffff"
}
Finding a valid nonce requires trillions of hash attempts. But verifying it takes milliseconds that asymmetry is the entire security model of Proof of Work. Once a block is found, it's broadcast and every other node verifies it instantly, then appends it to their chain.
05 Script
Bitcoin's tiny programming language
Every transaction output carries a scriptPubKey a small program in Bitcoin Script that defines the conditions for spending. The most common is Pay-to-Public-Key-Hash (P2PKH):
# Locking script (on the UTXO)
OP_DUP OP_HASH160 <pubKeyHash> OP_EQUALVERIFY OP_CHECKSIG
# Unlocking script (provided by the spender)
<signature> <pubKey>
Bitcoin Script is stack-based and intentionally limited no loops, no Turing-completeness. That restraint is a deliberate security choice. More advanced scripts power multisig wallets (requiring M-of-N keys), time-locks, and Lightning Network payment channels. Script is why Bitcoin is programmable money at the protocol level, not just a ledger.
This is for developers, not just traders
Understanding Bitcoin at the code level changes how you see the whole system. Transaction malleability, replace-by-fee, SegWit's witness data separation, Taproot's Schnorr signatures these aren't trivia. They're design decisions you'll encounter the moment you build anything on top of Bitcoin, whether that's a payment processor, a custody solution, or a Layer-2 protocol.
Running your own node also makes you a first-class participant in the network. You validate every block yourself. You don't trust anyone else's view of the chain.