My first impression of Cardano was a single word: slow. Other chains keep shouting about scaling and ecosystems; Cardano, after ten years, is still saying “our consensus paper got through another round of peer review.” I gave it the same nickname everyone does — the academic chain — and the same verdict: so slow, no good.

After actually digging into it, I’ve come to think that “slow” is the most valuable thing about it. Let me start from the bottom: how Cardano keeps its ledger, why it dares to write “security” into academic papers, and where it differs from Ethereum.

The ledger is UTXO, not accounts

Cardano’s ledger model comes straight from Bitcoin: it’s called UTXO (Unspent Transaction Output). The chain doesn’t store “user X has this much balance.” It records “which unspent outputs were spent by whom.”

That detail becomes decisive when smart contracts come up, so hold onto it. Ethereum uses an account model — every person has a balance variable, and transactions modify those variables. Cardano works by “spending old outputs and creating new ones.” State isn’t modified; it’s destroyed and recreated.

The consensus fork: PoW vs PoS

The first big fork between Cardano and Ethereum is consensus. Until it moved to PoS in 2022, Ethereum used Proof of Work (PoW) — hash power, whoever solves the puzzle first produces the block. Cardano has been Proof of Stake (PoS) from day one: the more ADA staked, the better the odds of being chosen to produce a block.

Under the hood is Ouroboros, the first Proof of Stake protocol with a rigorous security proof (published at CRYPTO 2017). That “first to have a proof” part matters more than it sounds. More on that below.

How an epoch works

Cardano time comes in two layers: one epoch (roughly 5 days) is split into 432,000 slots, one second each, and at most one block per slot.

The key part: who produces the block in a given slot is impossible to guess in advance:

flowchart TB
    A[A slot begins] --> B[Each stake pool<br/>evaluates the slot<br/>with its own VRF key]
    B --> C{Is the VRF output<br/>below the pool's threshold?}
    C -->|Yes| D[Produce block<br/>with a verifiable proof]
    C -->|No| E[Wait for the next slot]

One name matters here: VRF.

VRF: unpredictable, yet verifiable

VRF stands for Verifiable Random Function. It has three properties that sound contradictory and are actually exactly right. The output is unpredictable: before the slot arrives, nobody can compute who will be chosen. The output is verifiable: when a block is broadcast, it carries a proof, and the whole network can check that the producer really was selected. And probability is proportional to stake: the more stake, the higher the chance — but there’s no way to lock onto a specific producer ahead of time.

Put together, these three kill an entire class of attack: targeted attacks. In PoW, enough hashrate keeps aiming at the next block. On Cardano, even predicting who the next block producer is proves impossible, so there’s nothing to aim at. In the Praos security proof (EUROCRYPT 2018), the VRF is formally modeled with an explicit requirement to stay unpredictable “under malicious key generation.”

Compared with Ethereum’s PoW, the difference is more than electricity

PoW vs PoS is usually boiled down to “wasteful vs efficient,” but the real difference is the trust model. PoW runs on hashrate: whoever has 51% of the hash power can reorder history and double-spend; the attacker’s cost is electricity and mining hardware, an endlessly burnable resource war. PoS runs on stake: misbehaving costs the perpetrator their stake, real money locked inside the protocol; reorging the chain demands controlling a large share of stake, and once the cheating is detected, the stake is slashed.

A rough analogy: PoW buys security with money spent; PoS secures trust with money on deposit. For a chain whose job is settlement, the latter fits better.

What it means to write “security” into a paper

The most mocked thing about Cardano is also its most underrated feature: Ouroboros’ security isn’t the “we got audited” pitch. It’s provable security.

Here’s how it works. A paper first states its assumptions — for example “the attacker controls less than half of the stake” or “message delays are bounded.” Then, under those assumptions, it proves mathematically that the protocol is secure: no matter how the adversary flails, there is no path that breaks the chain. Praos goes further: the adversary can corrupt any participant at any moment, adaptively, as long as honest parties keep a majority of the stake.

That’s a completely different promise from auditing. An audit answers “does the current code have obvious bugs?” A proof answers “within the stated assumptions, there is no path that breaks the protocol.”

For a chain entrusted with real money for the long haul, the second answer is a lot closer to what’s needed.

Why “slow” is the right pace

So “why is Cardano so slow?” has an answer: it’s not that the team can’t write code. It chose “prove first, ship later.”

Ethereum’s path is “ship it, then patch it in incidents.” Cardano’s path is “argue it thoroughly, then ship the code.” The first iterates faster, but every upgrade is surgery on a system already carrying real money. The second is slow, but every step stands on a proved foundation.

The result is plain to see: Ethereum’s eras are full of post-incident patches and post-mortems, while Cardano — from Shelley (when proof of stake went live, 2020) to today — has barely had to rework its core consensus because of a design mistake. A decade in, that kind of “the foundation won’t suddenly crack” certainty is what I value most. Slow in the short run buys stable in the long run.

Article Link: