DeFi Summer 2020: How Decentralized Finance Changed Crypto

In early 2020, “DeFi” still sounded like something you’d have to explain twice at a party.

By late summer, it was the party.

Tokens were flying. Yields were ridiculous. Protocol dashboards looked like flight cockpits. And a new phrase entered crypto’s daily vocabulary:

yield farming.

But DeFi Summer wasn’t just hype. It was a real structural shift: finance features that used to belong to banks — lending, borrowing, market making, interest rates — were suddenly running as public smart contracts. Anyone with an internet connection could plug in.

So what actually happened in 2020, and why did it change crypto’s trajectory?

Let’s break it down.

 

1) The setup: DeFi existed before summer 2020, but it wasn’t “alive” yet

Before the boom, the core ingredients were already on the table:

• Ethereum smart contracts (the platform)
• stablecoins (the unit of account)
• early lending and trading protocols
• and a growing culture of on-chain composability (“money legos”)

The missing piece was a reason for millions of dollars to show up quickly and stay.

That reason arrived in one word:

incentives.

2) The spark: Compound’s COMP turned “using DeFi” into a paid job

In June 2020, Compound began distributing its governance token COMP to users of the protocol — lenders and borrowers — effectively paying people to participate. Compound framed this as the final step in decentralizing control of the protocol in its update COMP Distribution, Key Delegates, New Asset Pages.

This did something simple but explosive:

• Lending and borrowing were no longer just financial actions.
• They became reward-generating strategies.

Suddenly, users weren’t only earning interest. They were earning token emissions on top.

That is the psychological shift that kicked off “DeFi Summer”:

DeFi stopped being a tool, and became a game with a scoreboard.

3) Yield farming, explained like a human (not a spreadsheet)

Yield farming is basically this:

“Where can I put my assets so I earn the most total return, including protocol rewards?”

Sometimes that meant:

• supplying USDC to earn interest plus token rewards,
• borrowing against collateral to loop positions,
• moving funds between protocols like a shopper chasing discounts.

And because everything was programmable, users could chain protocols together—deposit here, borrow there, swap somewhere else—without asking permission.

This stacking effect is the core DeFi “wow”:

one protocol becomes another protocol’s building block.

4) Why Uniswap mattered: it made token markets frictionless

In May 2020, Uniswap v2 launched on Ethereum mainnet. The official release post is Uniswap v2 Mainnet Launch.

Uniswap’s impact on DeFi Summer was massive because it made one thing easy:

instant liquidity for basically any ERC-20 token.

That meant:

• new tokens could trade quickly,
• farmers could swap rewards into other assets,
• and DeFi strategies could move fast without relying on centralized exchanges.

Then, in September 2020, Uniswap introduced UNI, its governance token, in Introducing UNI — a move that also became part of DeFi Summer’s “token war” era.

5) Curve: the quiet machine that made stablecoin DeFi work

If Uniswap was the loud party, Curve was the high-efficiency engine room.

Curve specialized in swapping stablecoins and pegged assets with low slippage. The mechanism is based on the StableSwap invariant described by Michael Egorov in StableSwap – efficient mechanism for Stablecoin liquidity and explained in Curve’s docs Stableswap Exchange Overview.

Why this mattered in 2020:

• DeFi strategies often rotated through stablecoins.
• Stablecoin liquidity is the “cash layer” of on-chain finance.
• Curve made that cash layer far more efficient.

Curve also became a center of incentive battles (liquidity gauges, vote power, and “Convex-era” dynamics later), but in 2020 the core story was simple:

Stablecoin liquidity became industrial-grade.

6) The “vampire attack” moment: SushiSwap and the realization that liquidity is portable

In late summer 2020, a fork called SushiSwap introduced aggressive incentives designed to pull liquidity from Uniswap — what the industry famously called a “vampire attack.”

The historical details are messy across many threads, but the key concept became permanently important:

Liquidity can move. Fast.

In DeFi, users aren’t “customers” locked into an app. They’re liquidity providers and traders who can leave the second incentives change.

That one fact reshaped how protocols think about:

• token distribution,
• governance,
• and how to defend a moat without owning users.

(And yes — Uniswap’s UNI launch in Introducing UNI sits directly in this context.)

7) “Money legos” becomes real: DeFi composability at scale

During DeFi Summer, a typical advanced user flow could look like:

1. Deposit collateral into a lending protocol
2. Borrow a stablecoin
3. Provide liquidity in an AMM
4. Stake LP tokens for additional rewards
5. Loop it again (sometimes with leverage)

Each step might be a different protocol, but the user experience was “one financial strategy.”

This is why DeFi felt so new: it wasn’t one product. It was an ecosystem of interoperable financial primitives.

8) The scoreboard: TVL became the headline metric (with real caveats)

As money poured in, the industry needed a simple way to describe DeFi’s growth. The metric that won was Total Value Locked (TVL) — the dollar value of assets deposited in DeFi protocols.

Aggregators like DefiLlama turned TVL into a public, constantly updating leaderboard.

Two important truths can both be true here:

• TVL captured real growth and attention.
• TVL can be misleading (double-counting, looping leverage, inconsistent accounting).

Even the Bank for International Settlements has examined how TVL is computed and why verifiability is tricky in Towards verifiability of total value locked (TVL) in DeFi.

So: TVL is useful as a temperature check, not a perfect “size of DeFi” number.

9) The dark side: DeFi Summer also taught brutal lessons

DeFi Summer didn’t just create wealth. It created new kinds of failure at high speed:

Smart-contract risk became mainstream

If the code has a bug, the money can be gone instantly.

Leverage loops magnified crashes

Strategies that looked safe in calm markets could unwind violently during volatility.

Governance became a battlefield

Token voting isn’t magically wise. It can be captured, manipulated, or simply chaotic.

DeFi’s promise is “don’t trust humans.” But DeFi’s reality is: humans still choose the code, the parameters, and the incentives.

The simple takeaway

DeFi Summer 2020 was when crypto learned a new trick:

You can build financial markets as open software.

COMP proved incentives could bootstrap usage. Uniswap proved liquidity could be permissionless. Curve proved stablecoin liquidity could be efficient. And the whole ecosystem proved composability could turn separate apps into one programmable financial system.

But it also proved something equally important:

When finance becomes code, bugs, incentives, and leverage become systemic risks — at internet speed.