Blockchain app development cost: rates, audits, gas and a worked budget

A blockchain app costs what its team's hours cost, plus an audit, plus a usually small amount for gas and infrastructure. This article gives a sourced number for each part: published developer rate data, public audit prices, deployment gas measured on 30 October 2026, and the listed prices of node and indexing services. It ends with a worked budget for one example app.

Agency price guides mostly give ranges without saying where the numbers come from, and the ranges disagree with each other. The first section shows them side by side, and the rest of the article builds a budget from the parts.

What agencies quote, and where they disagree

The pages that rank for this topic are mostly written by development agencies. Each one publishes its own ranges. The table puts three of them next to each other, and none of the three states how its ranges were collected.

Sources: Appinventiv, Purrweb and Alchemy, read on 30 October 2026.

The ranges disagree in several places:

• A "token" costs anything from $200 to $15,000, because Alchemy counts only the contract and Appinventiv adds a website and a sale contract.
• Appinventiv gives a dApp two different ranges on the same page: $35,000–$150,000 in its table and $75,000–$150,000 in its dApp section.
• ScienceSoft gives one overall range of $50,000 to more than $2,000,000.
• Dotsquares prints its enterprise range as "$800,000 – $200,000+", where the low end is higher than the high end.

The spread comes from scope. A token contract built on audited library code is a small job, while an exchange needs order handling, custody, compliance and a much larger audit. A budget built from team-weeks, rates and fixed costs is easier to check than any of these ranges.

Labour: team size, weeks and hourly rates

Labour is the largest cost in almost every blockchain project. The estimate is people multiplied by weeks multiplied by a rate. This site's dApp development guide gives a typical team for a moderately complex EVM dApp, such as a staking or escrow product:

• one senior smart contract engineer for 6 to 10 weeks, including tests
• one backend engineer for 4 to 8 weeks on indexing and services
• one frontend engineer for 6 to 10 weeks
• design, QA and project management part-time throughout

Published rate data disagrees, partly because each source below measures something different:

Clutch puts US agencies in the same $25–$49 band as India and Ukraine, while Purrweb puts North America at $100–$200. Clutch does not give a sample size and ranks countries by its own site traffic, so its band describes agencies that list on Clutch, not the whole market. The BLS figure is a salary for all software developers, and an employer pays more than the salary once benefits, equipment and management are added.

The rate alone does not set the price. For example, a team that charges half the rate but needs twice as many weeks costs the same.

Smart contract audit cost

Most audit firms quote per project and do not publish a rate card. A few public sources give reference points:

• In a February 2024 application to the Arbitrum DAO, Trail of Bits priced its security work at $25,000 per engineer-week, or $600,000 for 24 engineer-weeks.
• The Security Alliance framework gives $1,000 to $60,000 per week, depending on complexity and auditor expertise. It estimates 1–2 weeks for code under 1,000 lines, 2–5 weeks for 1,000–4,000 lines and 5 or more weeks above that.
• Sherlock, which sells audits, puts a simple ERC-20 token at $5,000–$20,000 and most DeFi protocol audits at $25,000–$100,000. It adds $5,000–$20,000 for each re-audit pass after fixes, and a 25–40% premium for Rust and Solana code.

The number of auditor-weeks changes the price more than the weekly rate does. A small contract that uses OpenZeppelin libraries may need a few auditor-days, while new financial logic can need two or three auditors for several weeks. The smart contract audit guide covers audit contest prize pools, the audit process and how to compare quotes from several firms on the same frozen code.

Deployment and gas costs, measured

Deployment is usually the smallest line in the budget. To check the real figure, we compiled two standard contracts and asked live networks how much gas each deployment would use. The contracts were an ERC-20 token that mints one million tokens and an ERC-721 NFT contract with an owner-only mint function. Both were built on OpenZeppelin Contracts 5.1.0 and compiled with Solidity 0.8.28 with the optimizer on.

The measurements were taken on 30 October 2026 at about 08:46 UTC:

• The ERC-20 deployment uses 545,145 gas, and the ERC-721 deployment uses 1,063,586 gas (from eth_estimateGas on each network).
• The Ethereum mainnet gas price was 0.7046 gwei (block 26,303,067).
• The gas price on Base, a layer 2 network, was 0.006 gwei. Base also charges an L1 data fee, because it posts each transaction's data to Ethereum. Base's built-in fee contract put this fee at 0.0000000869 ETH for the token and 0.000000168 ETH for the NFT contract.
• ETH was $2,226.59 and SOL was $96.75 on CoinGecko.

The gas price on Ethereum changes from block to block, so the 20 gwei row shows how the cost scales when the network is busy. A full DeFi protocol deploys many contracts, so multiply by the number of contracts and add the transactions that configure them.

Solana works differently. Every account on Solana, including the account that holds a program's code, must keep a minimum SOL balance called the rent-exempt deposit. The deposit is returned when the account is closed. The deposit is (128 + the account's size in bytes) × the rent rate. The rate fell on mainnet in 2026 under the SIMD-0437 rent reduction, and further cuts are planned. On 30 October 2026 it was 5,080 lamports per byte (one SOL is one billion lamports). The figures below come from Solana's public RPC on that date.

• A new token on Solana usually uses the existing SPL Token program, so it needs only an 82-byte mint account. The deposit was 1,066,800 lamports, or 0.00107 SOL (about $0.10).
• A custom program needs an account that holds its compiled code. For a 200 KB program the deposit was 1.017 SOL, or about $98.
• Each transaction also pays a base fee of 5,000 lamports per signature, as described in the Solana fee documentation.

Gas becomes a real budget line when the app pays for its users' transactions. ERC-4337 paymasters and EIP-7702 let an app sponsor gas, which is a running cost that grows with every user. The dApp guide covers sponsored gas. The layer 2 scaling article covers how layer 2 fees work.

Node, RPC and indexing services

An app reads the chain through an RPC endpoint and usually reads history through an indexer. Few apps run their own nodes at the start, and the hosted services publish their prices:

Each provider counts usage in its own units, and one RPC call can cost several units. To compare plans, run the calls your app makes on each free tier and compare the usage. The fixed-price RPC plans from Infura and QuickNode start at $49 to $50 a month.

Enterprise permissioned chains

An enterprise network on Hyperledger Fabric has no gas, but each member organisation runs its own peers and certificate authority. Most of the work is integration with existing systems and network governance, not chain code. The Hyperledger Fabric explainer describes the parts of a Fabric network.

Amazon Managed Blockchain offered managed Fabric networks, but AWS stopped accepting new customers on 29 October 2026 and ends the service for existing customers on 29 September 2027. A new project has to plan for self-managed Fabric (for example on Amazon EC2 or EKS) or another managed provider. For reference, AWS's pricing examples put one production member at $1.93 an hour, which is about $1,409 a month over 730 hours.

Maintenance after launch

Agencies usually express maintenance as a share of the build cost each year. Appinventiv gives 15–25% and ScienceSoft gives 15–20%. Maintenance covers these items:

• RPC, indexing and hosting bills
• library and dependency updates, and fixes for new bugs
• a review of every contract upgrade, because upgraded code is unaudited until someone reviews it
• on-chain monitoring and an incident plan
• a bug bounty, whose rewards should match the funds the contracts hold

The smart contract security article describes monitoring, pause controls, bug bounties and incident plans.

Worked budget: a staking dApp on Base

This example is a staking app with one main contract of under 1,000 lines, a web front end and a small backend, deployed on Base. It uses the dApp team from the labour section, with design and QA counted as separate roles, for a total of 32 person-weeks:

• smart contract engineer, 8 weeks
• backend engineer, 6 weeks
• frontend engineer, 8 weeks
• design, 3 weeks
• QA, 4 weeks
• project management, a quarter of one person's time for 12 weeks, which is 3 weeks

At 40 hours a week, 32 person-weeks is 1,280 hours. The three rates in the table below come from the rate sources above: about the middle of Clutch's band, about the middle of Arc.dev's average band, and the middle of Purrweb's North America band.

Maintenance in the second year adds 15–20% of the build cost, which is $17,280–$23,040 at the $90 rate. The budget leaves out legal advice, a token launch, marketing, and app store accounts for a mobile version.

The audit and fix review are the same in every column, so at the $37 rate they make up 29% of the low total ($20,000 of $68,164) and 59% of the high total ($70,000 of $118,164). A cheaper team does not make the audit cheaper, and in Sherlock's figures each extra re-audit pass adds another $5,000–$20,000.

How to get quotes you can compare

1. Write the scope first. List the contracts, the chain, the user roles, the admin powers and the outside protocols the app calls.
2. Ask for person-weeks by role. A quote that shows the team and the weeks can be checked against the rate data above. A single total cannot.
3. Ask whether the audit is included. If it is, ask which firm, how many auditor-weeks and whether the fix review is included.
4. Ask who pays running costs. RPC, indexing, hosting and any sponsored gas should be in your own accounts, not the agency's.
5. Ask about maintenance terms. Get the monthly or yearly price and what it covers, including reviews of contract upgrades.

This site's blockchain development services guide covers scoping in more detail, and the DeFi development guide estimates the cost of a DeFi protocol by the same team-and-weeks method.

Frequently asked questions