Lesson 1— Ledgers You Can Trust — and Why Screenshots Lie

Ava doesn’t start with “crypto.” She starts with ledgers.

“Every system you’ve ever trusted,” she says, “runs on a ledger—who owes what to whom, what changed, and when. Most ledgers live inside institutions. You can’t see them. You ask for access, and someone with permissions gives you a balance, a statement, or a no.”

She draws two rectangles.

Left box: Private Ledger. A bank, an exchange, a game server. Fast, efficient, reversible—if the operator agrees. Edits, freezes, rollbacks and corrections all happen behind the glass. Trust flows toward the operator’s policies, uptime, and honesty.

Right box: Public Ledger. “Same idea,” Ava says, “different enforcement. Here, the rules for writing to the ledger are public; anyone can verify the result. No single hand can quietly alter yesterday. You don’t ask for a balance; you compute it from a record everyone can read.”

You look at the right box and ask the first beginner’s question out loud: “How can a public ledger avoid chaos? What stops someone from faking entries?”

“Two ingredients,” Ava says. “Signatures and agreement.”

Signatures. On the public ledger, an ‘account’ is just an address derived from a public key. To move value, you don’t send a password—you produce a digital signature with the matching private key. The network can check the signature against the public key and the message you claim to authorize, but it never learns (or needs) the private key.

“Think of a signature,” Ava says, “as a math proof that says, the holder of this secret approved this exact instruction. If the signature doesn’t match, the instruction is trash. If it does, the network treats it as the account holder’s intent.”

You ask if someone can guess the key.

“They can try,” Ava says gently, “the way you can try to count to the moon. The search space is astronomically large. In practice, failures here are human—phishing, fake sites, leaked seeds—not the math.”

Agreement. Thousands of nodes keep copies of the ledger and relay new signed instructions (transactions). But the network needs more than signatures; it needs a shared ordering of events. Otherwise, two people could spend the same coin in different directions at once.

“That’s the job of consensus,” Ava says. “We need a process that picks a single, canonical ordering of transactions and locks it in.”

She sketches the flow like a train timetable:

1. Users broadcast signed transactions.
2. A designated participant proposes the next block—a bundle of transactions that follow the rules.
3. The rest check the proposal and attest if it’s valid.
4. Enough attestations = the block becomes part of the ledger everyone keeps.

On Bitcoin, proposals are tied to proof-of-work: a costly puzzle shows you invested energy to earn the right to propose. On modern Ethereum, proposals and attestations come from validators who have staked value. If they cheat—by proposing conflicting histories or including invalid transactions—their stake can be slashed. The network coordinates honesty with incentives and visible rules rather than with a single authority.

“Don’t memorize the acronyms,” Ava says. “Hold the shape: proposals, checks, agreement, then finality—the moment the network commits to a specific ordering. Until finality, a block is like wet cement—it’s there, but you wait before walking on it. After finality, it’s the sidewalk.”

Immutability (what it is and what it isn’t).
You’ve heard “blockchains are immutable.” Ava nods, then trims the myth.

“Immutability isn’t magic; it’s costly to change. To rewrite a confirmed history, an attacker would need to out-compete or corrupt the consensus process itself—outspend the energy on a proof-of-work chain, or overwhelm/slash through the stake-weighted process on a proof-of-stake chain. Public chains make yesterday expensive to edit and obvious if someone tries.”

Immutability has a human face, too: no customer service to call for a polite reversal. The trade is control for certainty—you lose convenient reversals; you gain rules that apply the same to everyone.

Availability.
“Truth that you can’t fetch is useless,” Ava says. The network doesn’t just agree on the ordering; it makes data available so anyone can reconstruct the state. Modern designs separate “ordering” from “data availability” with mechanisms that force block proposers to publish the contents widely. If someone tries to hide data, the network refuses the block.

Liveness and censorship resistance.
What if someone tries to censor your transaction—never include it, even if it’s valid?

“Public networks assume the world can misbehave,” Ava says. “If one participant refuses you, another includes you. If a cluster censors, the rest route around it. Liveness means valid transactions keep getting in; censorship resistance means no single relayer or block producer can silence you for long.”

It’s not a guarantee of instant inclusion—fees, congestion, and policy can slow you down—but it’s a system-level design goal: no single choke point.

From ‘who’ to ‘how’.
Private ledgers maximize comfort: one operator, one phone number, one set of business hours. Public ledgers maximize neutrality: many operators, one rulebook, no private edit channel.

“You’re moving your trust,” Ava says, “from who runs the database to how the database is run in the open. That can feel unsafe at first because no one can fix a mistake for you. But it’s also why small actors get the same rules as large ones. Power doesn’t vanish—it becomes inspectable.”

“This right box,” she adds, tapping the public-ledger rectangle, “is why tokens can exist without a vault or a server with ‘admin.’ The ledger itself is the vault. The network is the guard. And the rules of entry—signatures, validity checks, consensus—are published for everyone to read.”