Open your wallet and you'll see a balance. That number doesn't exist on the network. Nowhere in the blockchain is your balance stored: what exists are pieces of money, each with an owner and its own value, and the balance is a sum that your app calculates before displaying the screen.
Each piece is called a UTXO, which stands for unspent transaction output. When someone pays you, the transaction creates an output with a value and a lock that only your key can open. As long as no one spends it, it stays there, whole, waiting. The network doesn't know how to sum them up: it only knows, for each one, whether it has been spent or not.
From this comes the rule that explains almost everything that follows: a UTXO is spent in full. You can't use half of it, just like you can't pay ten with half of a twenty bill. If you have a piece of 0.05 and need to pay 0.03, the transaction consumes the full 0.05 and creates two new outputs: one of 0.03 for the recipient and another, with the remainder, back to one of your addresses. It's the change that the beginner's path promised to explain in detail, and it's not a courtesy of the program: it's the only way to balance the account.
Each transaction, therefore, is a list of inputs and a list of outputs. The inputs point to previous outputs, indicating where the money comes from, and each comes with the signature that proves the right to spend it. The outputs indicate where it goes. The values are always whole numbers of satoshis — one hundred millionth of a bitcoin — because a whole number never rounds incorrectly.
And here's the detail that most surprises those seeing it for the first time: the fee isn't written anywhere. There's no fee field in a transaction. What exists is the difference: if the inputs sum up to more than the outputs, the remainder goes to the miner who includes the transaction in the block.
This design choice is elegant and unforgiving. On February 10, 2023, the American company Paxos broadcast a transaction that moved the equivalent of a few dollars and paid 19.8 bitcoins in fees — half a million dollars at the time. No one typed that value. Someone assembled the inputs and forgot the change output, and the network did exactly what the rule dictates: what didn't go to an output went to the miner. A common wallet protects you from this with checks; a manually assembled transaction does not.
With this model in mind, two everyday problems become obvious. The first is dust: pieces so small that spending them costs more in fees than they're worth. They remain in the wallet forever and even exist as a tracking technique — sending dust to thousands of addresses and observing who spends it along with the rest.
The second is consolidation. Those who receive many small payments accumulate dozens of UTXOs, and each one takes up space when spending — a transaction with thirty inputs is thirty times more expensive than one with one. Consolidating is combining them into a single transaction, done at a time of low fees, to pay cheaply today what would be expensive tomorrow. In exchange, consolidating publicly reveals that all those pieces belong to the same person, which is a topic for the privacy lesson later in the course.
That's why a full node doesn't store anyone's balances: it keeps the set of all unspent outputs of the entire network, a few gigabytes that answer the only question that matters when validating — does this piece still exist?
Still, the lock needs to be opened. Each output carries a small program that defines the condition for spending it, written in its own language. In the next lesson, the Script.