In 2025, decentralized finance surpassed $170 billion in total value locked, while stablecoin supply grew from $206 billion to over $300 billion, and the footprint continues to expand as more financial activity moves onchain.

Decentralized finance replaces intermediary-dependent financial systems with direct interaction on shared settlement infrastructure. Fintech teams can build financial products on deterministic systems where asset movement, transaction logic, and execution are defined in code and verified at the protocol level.

That model introduces new requirements around key management, transaction construction, and policy enforcement. The best infrastructure built for this environment abstracts those constraints without removing control.

This primer covers the regulatory landscape, how DeFi differs from traditional finance, what it enables, what developers need to understand first, and how the underlying toolchain fits together.

What is decentralized finance, and why is it important?

Decentralized finance is a blockchain-based settlement and execution layer for moving, holding, trading, lending, and programming value without relying entirely on traditional financial intermediaries. For fintech apps, it offers a way to support user-controlled assets through onchain infrastructure.

Bitcoin was the first large-scale implementation of decentralized settlement without a central intermediary, proving that value could move across a global network through cryptographic ownership and consensus rather than an institution-controlled ledger.

Modern DeFi extends that idea into programmable financial systems, where users can access payments, lending, trading, tokenized assets, and other onchain services.

Some examples:

Cross-border payments: Traditional cross-border payment systems rely on correspondent banks, operating hours, and multi-step settlement. DeFi replaces this with settlement that runs continuously, allowing transactions to execute and finalize without intermediary coordination or time constraints.

Lending: Instead of centralized underwriting and servicing, DeFi lending uses smart contracts, or rule-based programs that run on a blockchain, to enforce terms at execution. Liquidity is pooled, rules are transparent, and outcomes are determined by code.

Trading: Rather than routing through brokerages and fragmented venues, DeFi connects wallets directly to liquidity. Assets can be swapped and settled in a single flow without market-hour or clearing delays.

What ties these together is where control lives. In traditional systems, control sits with intermediaries that coordinate approval, execution, and settlement across multiple systems. In DeFi, that control shifts into the execution layer itself, where rules are defined in code and enforced when a transaction is created and signed.

The regulatory landscape: Why this is the moment for DeFi

DeFi used to sit outside most financial regulatory frameworks. That is changing. Around the world, regulators are defining rules for stablecoins, virtual asset service providers, custody, market conduct, and licensing.

The result is a patchwork. But it is a more buildable patchwork than fintech teams had even a few years ago.

DeFi is no longer purely experimental. Fintech teams can now build within defined regulatory boundaries in many major markets, but those boundaries differ by jurisdiction, asset type, custody model, and user flow.

DeFi vs. TradFi: what’s the same, what’s different

DeFi and TradFi both move value. The difference is architectural.

In TradFi, financial activity is coordinated through institutions. In DeFi, financial activity is coordinated through blockchains.

Several differences matter most for fintech developers:

• Custody: In DeFi, custody is defined by control of the private key. A non-custodial wallet is a wallet that gives the user authority over assets directly onchain, meaning the application does not hold or control the user’s assets on their behalf.

Modern wallet infrastructure makes this non-custodial model usable inside fintech applications by abstracting key management, managing authentication, and enforcing policy controls behind a familiar product experience.

• Settlement: In DeFi, transactions settle onchain according to block-time finality, usually in seconds to minutes. Once finalized, a transaction is generally not reversible unless the application has explicitly designed in dispute or recovery mechanisms.

This finality changes how teams handle reconciliation and risk. Controls need to be applied before execution, at the point where the transaction is approved and signed, rather than after funds have already moved.

• Composability: In traditional finance, each new service usually requires its own integration, account relationship, or intermediary. In DeFi, financial services are built as shared onchain systems that wallets can connect to directly.

That means one wallet can be used across many different applications, such as lending, trading, payments, or yield, without rebuilding the same financial connections each time. The wallet becomes the access layer, and the onchain services provide the rules for how value moves.

• Market structure: DeFi lending is not primarily peer-to-peer lending in the traditional sense. The dominant pattern is overcollateralized, pool-based lending, where users deposit assets into shared liquidity pools and borrowers take loans against collateral worth more than the amount they borrow.

Another common model is collateralized debt issuance, where users lock collateral in a smart contract and mint or borrow a stable asset against it. In both cases, lending is coordinated by onchain rules rather than direct matching between individual lenders and borrowers.

‍

The right mental model is that DeFi is a programmable settlement and execution layer. It gives traditional applications a new set of rails to use when they need continuous availability, direct asset movement, and rules that can be enforced before transactions are created and signed.

DeFi’s big unlocks for finance

With decentralized finance, applications can operate on shared settlement infrastructure where logic, asset movement, and verification happen in the same environment. That gives fintech teams capabilities that are difficult to replicate with traditional systems.

Some of these benefits include:

These capabilities are useful only if teams understand the operating model underneath them. With DeFi, value moves through wallets, execution happens through smart contracts, and risk has to be constrained before a transaction is signed.

What to know first about building financial applications onchain

Fintech developers do not need to become protocol researchers to build with DeFi. But they do need to understand the parts of the stack that affect their users’ funds.

Chains

In traditional finance, applications run across bank ledgers, payment networks, clearing systems, and internal databases. In DeFi, applications run on blockchains.

Ethereum remains the primary DeFi environment, with the deepest liquidity, protocol coverage, and developer tooling. Layer 2 chains, such as Base, Arbitrum, Optimism, zkSync, and Polygon, run on top of Ethereum as secondary layers. They process transactions more efficiently, then settle back to Ethereum for lower fees, faster UX, and Ethereum-backed security.

Solana is often used for high-throughput applications where latency, cost, and transaction volume matter. Bitcoin remains important for treasury, long-term holding, and Bitcoin-native settlement.

For app developers, selecting the right chain for their application is fundamental. Chain selection can affect  everything from available assets to liquidity, fees, transaction speed, wallet support, compliance workflows, and the user experience your product can deliver.

Tokens

Token standards define what an application can hold, transfer, approve, and interact with. For most fintech DeFi use cases, the starting point is ERC-20, the core standard for fungible assets such as stablecoins.

In practice, ERC-20 support is what lets an application work with assets like USDC or other stablecoins in a consistent way across wallets, smart contracts, and DeFi protocols.

Stablecoins are the primary settlement asset for many fintech DeFi applications. While most stablecoins are designed to track the value of a fiat currency, usually the U.S. dollar, they are not interchangeable from an infrastructure perspective.

Each stablecoin has different issuer relationships, regulatory considerations, liquidity profiles, redemption mechanics, and chain support. Those differences affect where the asset can be used, how reliably it can move, and what operational or compliance controls need to sit around it.

Token approvals, an important part of the security model, give a smart contract permission to move a user’s tokens for a specific action, such as a swap, deposit, or payment. If those permissions are too broad, a malicious or compromised contract may be able to move more funds than the user intended.

Application wallets should be able to simulate transactions, parse approval requests, and show users what they are authorizing. They should also enforce policies before anything is signed.

Gas

Gas is where blockchain mechanics often become a product issue. On Ethereum and all Ethereum-based chains, transactions consume gas units and are priced through network fees. 

For fintech teams, gas matters because it affects onboarding, transaction reliability, support burden, and conversion. Users may not understand why they need a separate token to move a stablecoin or why a transaction fails when network conditions change. Sponsored transactions and transaction management help move that complexity into infrastructure so the app can deliver a more predictable experience.

Smart contracts

Every protocol integration introduces dependencies the application has to understand. 

A fintech engineer does not necessarily need to write Solidity, the code that smart contracts are written in. But they do need to know what risk controls to ask for before routing user funds through a contract.

This is especially important when DeFi becomes part of a larger financial workflow. A swap or lending action may look simple in the UI, but underneath it may involve contracts, approvals, price feeds, liquidity pools, bridges, and signing flows. The application needs to understand those dependencies before execution, not after something fails.

Cryptographic keys

In onchain finance, a transaction is authorized by a cryptographic signature from the key that controls the account. That makes keys one of the most important parts of the application stack.

Keys  determine who can move funds, who can approve actions, which chains an account can operate on, and how transaction authority is delegated across users and automated systems.

For fintech developers, the two biggest concerns are where the key lives, and what it is allowed to authorize. If either is poorly defined, the application can expose raw signing authority or give compromised users more control than intended.

The DeFi infrastructure stack for fintech applications

The DeFi stack works best when each layer has a clear job. Wallet infrastructure controls keys and signing. Protocols define financial activity. Compliance services manage screening and regulatory workflows.

A clean architecture keeps those responsibilities separate. That separation lets fintech teams add onchain functionality without turning every integration into a custody, compliance, or security problem.

Wallet infrastructure and key management

Wallet infrastructure manages cryptographic keys and turns them into a controlled signing system. Instead of exposing a raw private key to the application, key management infrastructure ideally handles key generation, storage, signing, and policy enforcement outside the application boundary.

The result is a non-custodial model that can still feel like a modern fintech product. Users keep control of their assets, while the application can credential transactions through secure, policy-constrained signing instead of exposing raw keys or relying on manual approval workflows.

This is the layer where Turnkey fits. For most fintech teams, building wallet infrastructure in-house means taking on the full burden of secure key operations, policy enforcement, recovery, chain support, and audit readiness. That typically means several engineering years of work before the product ever reaches users.

RPC and onchain interaction

Applications interact with blockchains through RPC nodes like those offered by Infura or Quicknode. These nodes expose network state, support transaction simulation, and accept signed transactions for broadcast. In practice, the app prepares an onchain action, the wallet signs it, and the RPC layer delivers it to the network for execution.

Turnkey's transaction management abstracts away this RPC complexity. Its send-transaction endpoints handle transaction signing, broadcast, and status monitoring in a single call. You pass a minimal payload; Turnkey auto-fills the rest and eliminates the need for a separate RPC provider on supported chains (Ethereum, Base, Polygon, Arbitrum, and Solana). 

For many fintech applications, transactions are not just a simple transfer. It may involve a smart contract call, a treasury operation, or a protocol interaction that needs to be constructed, reviewed, approved, and tracked.

Turnkey’s smart contract management capabilities help teams control who can initiate contract actions, which contracts can be interacted with, and what approvals are required before a transaction is signed. RPC providers handle connectivity to the chain. Turnkey handles the signing and policy layer around the action itself.

Fiat onramps

Fiat onramps let users fund their wallets directly inside the application. Turnkey supports onramp flows through integrations with MoonPay and Coinbase, enabling users to convert traditional currency into crypto without leaving the product experience.

With Turnkey, the onramp fits into the same wallet flow as the rest of the application. Users can fund a wallet, receive assets under their control, and continue into onchain actions through the app’s existing signing and policy infrastructure.

Stablecoins and crypto-native assets

Stablecoins are the default settlement asset for many fintech DeFi applications, but they are not the only assets teams may need to support. Depending on the product, applications may also need to support crypto-native tokens used for network fees, protocol access, governance, or trading.

Selection should be based on user geography, chain support, liquidity, redemption model, and regulatory posture.

The important point is that assets are not just product options. They shape settlement, treasury operations, compliance requirements, and the user experience. Turnkey supports a broad range of tokens across multiple networks, giving teams the flexibility to design asset support around the product they are building.

Third-party DeFi protocol integrations

Financial activity like lending, trading, yield, RWA access, and prediction markets happens through third-party protocols. With Turnkey, teams can integrate those protocols into their applications while using Turnkey for the wallet infrastructure, policy controls, and secure signing needed to support user-controlled access.

Lending

Morpho is one example of how a lending protocol can pair with Turnkey's wallet infrastructure. Morpho defines the market mechanics: collateral rules, interest rates, vault logic, liquidations, and risk parameters.

Turnkey creates and secures the user-controlled wallet, enforces signing policies, and credentials every transaction before it reaches Morpho's contracts. The application can connect users to collateralized credit markets through Turnkey and Morpho without becoming the lending protocol or the custodian.

Yield and staking

Yield.xyz provides a unified API for staking and yield across 75+ networks. Instead of building and maintaining individual protocol integrations, a fintech team can integrate Yield.xyz once and let Turnkey handle signing and policy enforcement on the transactions that flow through it.

The value of this pattern is operational: the yield provider routes capital, while Turnkey's policy engine restricts which vaults, tokens, and contract calls the wallet is allowed to interact with.

Trading infrastructure

Trading products tend to require the most moving parts: embedded wallets, session-based signing, execution integrations, and policy controls all running in concert. The execution layer varies by market and chain. 0x can handle EVM swaps, Jupiter handles Solana swaps, and Li.Fi or Relay can handle cross-chain swap and bridge flows.

These providers sit around the wallet. The application gets quotes, prepares the transaction, and routes execution through whichever integration fits the trade. Turnkey authenticates the user, controls the wallet, signs the transaction, and enforces policies before submission. The execution provider never touches the key.

Prediction markets

Prediction markets introduce a different execution pattern. Users are not swapping assets; they are taking positions tied to real-world event outcomes, with market creation, outcome resolution, and liquidity handled by the platform.

Turnkey's role here is the same as in any signing flow: wallet creation, authentication, and policy-controlled signing. But the compliance and product considerations differ. Prediction market positions carry event risk, regulatory sensitivity, and settlement mechanics that fintech teams need to evaluate independently of the wallet layer.

Card issuance

Stablecoin-funded card programs connect stablecoin balances to card spending through card networks, issuers, and crypto infrastructure companies. The architecture separates the user wallet, the stablecoin balance, the card issuer, and the settlement flow into distinct layers.

Turnkey provides the wallet that holds stablecoins, enforces transaction rules, and signs movements into the card settlement flow. Card issuance, network processing, and compliance sit with the issuer and the card network.

‍Exchanges

Decentralized exchanges often work differently from other DeFi protocols. Instead of sending every action as a standard smart contract transaction, users may sign structured messages, formatted instructions that describe a specific action, for actions like placing orders, managing positions, or approving trading permissions.

Hyperliquid is one example. Its order book and trades are fully onchain and self-custodial, but HyperCore uses structured messages for operations like order placement and agent approvals rather than standard Ethereum transactions.

Turnkey can parse these payloads directly and enforce rules through policy before anything is signed. Multiple projects in the Hyperliquid ecosystem already use Turnkey for policy-enforced automation, including mobile trading apps, liquid staking protocols, automated vault strategies, and Telegram-based trading bots.

RWA platforms

Tokenized treasury and credit products are bringing familiar financial instruments onto blockchain rails. The issuer provides the asset and defines eligibility, redemption, disclosures, and risk. The protocol or platform handles the onchain representation.

Turnkey provides the wallet that can hold and transact with these tokens. For fintech teams, the important consideration is that RWA tokens often carry transfer restrictions, accreditation requirements, or jurisdictional constraints that need to be enforced at the policy layer before a signature is produced.
‍

Compliance tooling

Compliance is its own layer. Screening, monitoring, and travel rule workflows typically come from specialized providers, and the fintech application is responsible for assembling the compliance model that fits its markets, users, and regulated activity.

Turnkey’s policy engine can help applications enforce compliance-related controls at the signing layer. Policies can restrict which wallets, contracts, assets, or transaction types are allowed, require approvals for higher-risk actions, and prevent transactions that fall outside defined rules from being signed.

This gives teams a way to turn compliance decisions into execution constraints. Once the application defines what should be allowed, Turnkey can help enforce those rules before funds move.

A reference architecture: how all these DeFi layers fit together into one transaction flow

A fintech app that connects users to DeFi rails might follow a flow like this.

A user signs up with email and adds a passkey. Turnkey creates a non-custodial wallet behind the scenes. The user experiences a familiar onboarding flow, while the application gets a wallet architecture designed for user-controlled assets.

The user funds the wallet with USDC through an integrated onramp. From there, the user can send stablecoins, swap assets, access tokenized treasuries, borrow against collateral, or fund a card flow. Each action triggers a signing request.

Before any signature is produced, the signing request is evaluated against policy. Daily limits, allowlists, contract permissions, approval thresholds, and other rules can be enforced before the transaction reaches the blockchain.

The fintech app never holds the private key or operates secure enclaves directly. Instead, the team can focus on the product experience, compliance flow, and protocol integrations while relying on wallet infrastructure for controlled signing.

This is the bridge between fintech UX and DeFi execution. The user sees a product that feels simple and familiar. Underneath, the application routes value through programmable settlement infrastructure, with Turnkey providing the wallet layer.

Turnkey: DeFi for TradFi

Fintech teams do not need to rebuild the whole DeFi stack to start using it. They need to choose the right layers, define the right controls, and keep the architecture precise.

• Start with the chain. Ethereum and L2s offer the deepest DeFi liquidity. Solana is useful for high-throughput consumer experiences. Bitcoin is often better suited for treasury and long-term holding.
• Choose stablecoins based on chain availability, liquidity, redemption model, and regulatory wrapper. Define the custody model early. For many fintech-DeFi products, non-custodial wallets provide the best balance of user control, risk separation, and product flexibility.
• Then configure policies before users move meaningful value. Define who can sign, what they can sign, when approvals are required, and how recovery works. From there, connect the compliance systems your product needs, including identity verification, transaction monitoring, and market-specific regulatory controls.
• Then prototype the wallet flow, connect one protocol integration, and test the full execution path from authentication to settlement.

Decentralized finance is no longer experimental infrastructure. It is a production-ready settlement layer fintech teams can build on right now.

Get started with Turnkey today‍