Skip to content
Blockchain & Web3All articles

Smart Contract Development: Lifecycle, Patterns, Cost

Smart contract development is mostly verification, not typing. This guide walks the lifecycle from specification to monitoring, with Solidity code, a language and chain comparison, exploit losses measured from DeFiLlama, and what an audited build costs.

Artem Zaitsev
Artem ZaitsevCTO · Idealogic
Author: Artem ZaitsevPublished: Updated: Reading time: 25 minHow we write →
On this page
Smart contract development lifecycle guide by Idealogic

Smart contract development is the work of specifying, writing, testing, auditing, deploying and operating programs that run on a blockchain and enforce rules without an operator who can override them. Ethereum's own documentation describes a smart contract as a program that lives at a specific address and carries its own code and state. That address is public, the bytecode is usually frozen, and interactions with it are irreversible.

This guide is written from the build side. It walks the lifecycle stage by stage, names the tools teams actually run in 2026 with their current versions, shows the DeFi patterns you'll end up writing, and covers the smart contract security data that decides most budgets. It also puts numbers on the two questions clients ask first: what it costs and how long it takes.

The short version

  • The lifecycle runs specification, architecture, implementation, testing, audit, deployment and monitoring. Writing code is the smallest stage in it.
  • Solidity is the default because the EVM bytecode it produces runs unchanged on Ethereum, Base, Arbitrum, Optimism and Polygon. Rust plus Anchor covers Solana, Move covers Aptos and Sui.
  • Of the $9.25 billion DeFiLlama recorded as lost across 920 attacks on DeFi protocols by 10 September 2026, the largest single category is a compromised key at $1.92 billion, ahead of every code bug class.
  • Access control errors cost $1.54 billion and share accounting errors $1.36 billion, which is more than oracle manipulation and re-entrancy put together.
  • An audited build costs two lines: engineering, and the audit itself. Sherlock's 2026 reference puts a mid-complexity DeFi audit at $40,000 to $100,000.
  • Deployment gas is now rounding error. A contract at the 24,576-byte ceiling cost about $1.22 to deploy on Ethereum mainnet on 10 September 2026.

What is a smart contract, and what smart contract development involves

A smart contract is a program stored on a blockchain that runs automatically when predefined conditions are met, holds its own state and assets, and can't be altered by a single party once deployed. Put shortly, it's a program with a bank account, and the network enforces its rules where a company otherwise would.

Ethereum's docs borrow Nick Szabo's vending machine as the analogy: money plus a selection equals a snack, with nobody in the middle deciding whether you deserve one. What makes the analogy useful is that the machine's behavior gets fixed before anyone puts a coin in.

That makes smart contract development an odd kind of software work. Deployed code can't be deleted by default and, in most designs, is immutable once it lands. You get no staging window between a bug shipping and an adversary finding it, because the adversary reads your source on the block explorer at the same moment your users do.

What a smart contract developer does

A smart contract developer designs the on-chain half of a product and then spends most of the week trying to break it. The job starts with a business rule and ends with a state machine: which states the contract can occupy, which transitions are legal, who may trigger each one, and what must remain true regardless of input. From there it is Solidity, Rust or Move, then unit tests, then fuzzing and invariant runs, then static analysis, then fixing what an external audit finds, then a deployment script that gets dry-run on a testnet before it touches mainnet, then source verification, then monitoring the live address. A good developer also knows which parts of the product should never go on chain at all.

What an example of a smart contract looks like

Escrow is the cleanest example, because the contract's job is exactly the job a person used to do. Funds sit in the contract instead of with an agent, the contract carries the conditions both parties agreed to, and it releases to the seller or refunds the buyer when those conditions resolve. We built that for Zert, a smart contract escrow platform where escrow accounts hold the value and contract code referees the exchange, with the whole thing hidden behind ordinary product screens.

The other everyday example is a token. An ERC-20 contract tracks balances, moves them on transfer, and lets one address spend on another's behalf through an allowance. On top of a standard library that is about a hundred lines, which is why token work is the entry point for most teams and why creating a cryptocurrency is a solved problem compared with everything downstream of it.

The smart contract development lifecycle, stage by stage

Each stage settles one decision before the next one gets expensive to change

Every stage of the smart contract lifecycle below settles a specific decision. Skip a stage and the decision is still there, only now it sits somewhere it costs more to reverse. OpenZeppelin's own readiness guide walks through planning, testing, audit, deployment and monitoring too, so this sequence is how the industry works and not one agency's house style.

Smart contract development starts with a spec

The decision it settles: what must always be true. Before any code, write the state machine and the invariants. The sum of all shares equals total supply. Recorded assets never exceed the contract's actual balance. No account can withdraw more than it deposited plus what it earned. These sentences become your fuzzing oracle later, which is why vague ones produce vague tests.

The threat model is the other half. What happens if the same function is called twice in one block? If a token transfer returns false instead of reverting? If the oracle returns zero, or a stale price, or a price that moved 40 percent in one block? Write the answers down while changing them is free.

Architecture and contract patterns

Architecture is where you decide how much surface you're exposing. You choose how many contracts there are, which of them hold funds, whether anything is upgradeable, and what stays off chain entirely. That last question is the one most teams underweight. On SeedBox, the DeFi investment platform we built for a crypto venture group, the split was deliberate: trustless logic and settlement went into Solidity, while investor profiles, verification status, tier assignments and referral graphs stayed in PostgreSQL where they are fast and fixable. A smaller contract surface is a smaller audit and a smaller blast radius.

Upgradeability is a real trade. A proxy lets you fix a bug; it also hands anyone who takes your admin key the ability to replace the entire contract. DeFiLlama's hacks database lists about $198 million lost across ten incidents to uninitialized proxies alone, and $150 million of that is the Parity multisig freeze of November 2017.

Implementation: Solidity development in practice

Good Solidity is deliberately boring, and the decision this stage settles is how much of it you write yourself. Standard tokens, access control, pausing and re-entrancy guards come from OpenZeppelin Contracts, on v5.7.0 since 29 July 2026, so the only novel code in the repository is the protocol's actual logic. The compiler moves faster than people expect: Solidity 0.8.38 shipped on 22 October 2026, six weeks after 0.8.37, and the 0.8 line has made arithmetic overflow revert by default since 0.8.0 in December 2020.

Two habits matter more than any style guide. Order every function as checks, then effects, then interactions. And treat every external address as hostile, because a token you call might be a contract written to call you back mid-execution.

Testing: unit, fuzzing and invariants

Testing tells you whether your invariants survive input you didn't imagine. Unit tests are the floor. The layer that finds real bugs is property-based: a fuzzer throws thousands of randomized call sequences at the contract and checks that the invariants from stage one still hold.

The current toolchain is short. Foundry, on v1.9.0 since 2 November 2026, ships forge, cast, anvil and chisel, with fuzzing and invariant testing built in and documented handler-and-ghost-variable patterns for stateful runs. Hardhat 3 went stable on 1 June 2026 and now runs Solidity tests alongside TypeScript ones, with 3.22.0 published on 12 November 2026. For deeper campaigns, Trail of Bits maintains Echidna, on v2.4.0 since 4 November 2026, and its Go-based sibling Medusa v1.5.1, and Certora ships a formal-verification prover, on 8.20.3 since 26 October 2026. Fork testing against live mainnet state isn't optional either, because that is where you meet the fee-on-transfer token that breaks your accounting.

Ethereum's testing documentation is candid about the ceiling here: rigorous testing rarely guarantees the absence of bugs, which is the argument for the next stage.

Audit

The decision it settles: whether anyone who did not write the code agrees it is safe. Run Slither first, on 0.11.6 since 28 July 2026 with dozens of built-in detectors, so the automated bug-class signatures are gone before a human bills you for finding them. Then commission an external review.

What separates a useful audit from a logo on a PDF is whether the auditors run their own tooling and write their own tests rather than skimming yours, and whether findings arrive with a reproducible proof-of-concept rather than a paragraph of concern. Severity grading has to be honest too, which is easier to check than it sounds: ask what the last three criticals were. Plan for findings, a rewrite and a second round after the fixes, because a first-pass clean report usually means the scope was too narrow. Our full smart contract audit walkthrough covers what a report should contain and how to read one.

Deployment: testnet, mainnet, verification

Deployment is code: reviewed, dry-run on a testnet, never typed into a console. The decision it settles is who holds power over the live contract afterwards. Constructor arguments, initial owners and admin roles get checked twice, because a mistyped owner address is unrecoverable. OpenZeppelin's guide makes a specific point of not assigning roles from msg.sender in a deploy script, which is how deployer keys end up as permanent admins by accident.

After deployment, verify the source on the block explorer. An unverified contract asking for token approvals is a signal informed users read correctly.

Monitoring and upgrades

Monitoring decides how fast you find out. A live contract is production, and production needs observability: event streams, treasury balances, alerts on abnormal flows, and an incident runbook that names who can pause what.

This is also where the tooling shifted recently, and it's worth knowing before you build a runbook around a product that is gone. OpenZeppelin Defender closed new sign-ups on 30 June 2025 and shut down on 1 July 2026. Only its Relayer and Monitor functions carried over, as open-source, self-hosted projects that OpenZeppelin still ships and updates. Tenderly remains the other common choice, with transaction simulation, an opcode-level debugger, gas profiling and alert routing.

Planning a contract that will hold real money? We scope the audit into the build, not after it
See our blockchain engineering work

Smart contract languages and chains, compared

Solidity development is the default because of bytecode portability, more than anything in the language design. The same compiled artifact runs on Ethereum and on every EVM-compatible chain, so a team that learns one execution model can ship to several networks. Ethereum's languages documentation names Solidity and Vyper as the two most actively maintained options for the EVM, with Yul as a low-level intermediate language and Fe still early.

LanguageRuntimeToolingNotable users
SolidityEVMFoundry, Hardhat, OpenZeppelin, Slither, EchidnaMost of DeFi on Ethereum, Base, Arbitrum, Optimism, Polygon
VyperEVMTitanoboa, the same EVM analyzers, stable at 0.4.3Curve's stableswap contracts
RustSolana VMAnchor 1.2.x, LiteSVMMost Solana DeFi
MoveMove VMAptos CLI and Move Prover, Sui Move toolchainDeFi on Sui and Aptos

Vyper is the deliberate minimalist: Python-shaped, with no class inheritance and no modifiers, and code reuse goes through modules since 0.4. That's on purpose, so a reviewer has less to hold in their head. Curve's stableswap contracts are the best-known production codebase written in it.

Off the EVM the model changes more than the syntax. Solana programs are stateless and account-based, and Anchor hides most of the account-validation boilerplate, with 1.2.2 the latest stable release since 3 November 2026. Move takes a different route again: Sui's version removes global storage entirely so transactions on unrelated objects can execute in parallel, and every object carries an id field of type UID as its first property. Aptos runs a Move 2 compiler with a formal-verification prover in the standard toolchain.

The practical read: pick Solidity unless a specific chain requirement pushes you off it, because the auditor pool, the library ecosystem and the volume of public post-mortems are all deepest there. The wider architectural context of that choice sits in our guide to web3 development.

DeFi contract patterns you will actually write

Most DeFi products are recombinations of four patterns, and smart contract development in DeFi is mostly a matter of knowing which one you're in. Learning them properly is what lets you notice when something is subtly wrong, and each one has a signature failure mode with a measured price tag attached. The categories those patterns serve are mapped in our explainer on DeFi protocols and their types.

Vaults and share accounting

A vault takes deposits, does something productive with them, and tracks each depositor's claim as shares. ERC-4626, created in December 2021 and now final, standardized the interface so vaults compose predictably, and it is explicit that rounding should favor the vault over its users.

The skeleton is short because the standard library carries the accounting. On OpenZeppelin Contracts v5.7.0 and Solidity 0.8.38, a vault inherits the ERC4626 extension, passes the underlying asset token to the constructor, and overrides a single function, _decimalsOffset, to return a value such as 6. The ERC4626 extension needs a recent 0.8.x compiler, so check the pragma in the OpenZeppelin version you install.

That one override is the part that matters. The classic vault bug is the inflation or donation attack: someone deposits one wei, receives one share, then sends a large amount of the underlying token straight to the vault. One share is now worth a fortune, and the next honest deposit rounds down to zero shares. OpenZeppelin's ERC-4626 documentation works through the arithmetic and shows that virtual shares plus a decimals offset flip the economics, so the attacker loses at least as much as the victim deposits.

The bug still costs money. DeFiLlama's hacks database attributes $373 million across sixteen incidents to donation attacks, including Euler V1 at $197 million in March 2023. It files Tectonic, $124 million on 30 August 2026, under the same label, although Quantstamp's write-up describes that one as price manipulation with inflated collateral.

Automated market makers

An AMM replaces the order book with a formula. The constant-product model holds x * y = k across two reserves, so price slides along a curve as people trade against the pool. Nobody posts bids and no counterparty has to show up, because the equation and the pooled liquidity do that job.

The subtleties live at the edges. Every swap needs a minimum-output check and a deadline, or a bot sandwiches the trade and takes the difference. Pools that assume the amount received equals the amount sent break on fee-on-transfer and rebasing tokens. And the pool's spot price is manipulable inside a single transaction, which makes reading it as an oracle one of the most expensive habits in the space. We go deeper into the mechanics and the operator economics in our guide to decentralized exchange development.

Staking and reward distribution

Staking pays out over time in proportion to stake. The naive version loops over stakers to update balances and runs out of gas the moment the protocol succeeds. The standard fix is an accumulator: track one global reward-per-token figure, store each account's value at its last interaction, and compute pending rewards as the balance multiplied by the difference. Gas stays constant, nothing loops, and every account gets the right figure.

The failure mode is ordering. Update the accumulator after a balance change instead of before and rewards leak on every deposit and withdrawal path you forgot to touch. If the token itself has emission rules that interact with this, our guide to tokenomics covers the design side of that question.

Lending, and the re-entrancy fix everyone should be able to write from memory

Lending markets combine the other three: collateral in a vault, prices from an oracle, interest accruing per block. They are also where the oldest bug in the field still lands. The vulnerable withdraw checks the caller's balance, sends the funds with a low-level call, and only subtracts the amount after that. When the recipient is a contract, receiving funds hands it control. It calls back into withdraw while balances still says it is owed money, and keeps going until the pool is empty. The fix takes two changes used together: follow checks, then effects, then interactions, so the balance is subtracted before the external call, and put OpenZeppelin's nonReentrant guard on the function.

Modern tokens make the trap easier to fall into. ERC-777 can call a hook on the recipient during a transfer, and so do the safe-transfer functions of the NFT standards, so a function can be re-entered through what looks like a plain token movement.

Every one of these patterns is documented in public. Exploits tend to land in the integration between two of them, which nobody audited because each piece looked fine alone.

Smart contract security pitfalls, measured by what they cost

Losses on the DeFi protocols subset of DeFiLlama's hacks database (its target type filter), by DeFiLlama's own category, from 920 incidents totaling $9.25 billion. Captured 10 September 2026

Smart contract security is easier to budget once the losses are sorted by cause. On 10 September 2026, DeFiLlama's hack database showed $9.25 billion lost across 920 attacks on DeFi protocols, out of $20.65 billion across about 1,260 incidents when you count exchanges, bridges, tokens and everything else. The database has grown since, so treat every figure in this section as that day's snapshot. Sorted by DeFiLlama's own categories, the biggest line has nothing to do with Solidity. Key compromise accounts for $1.92 billion across 68 incidents, ahead of access control at $1.54 billion, share accounting at $1.36 billion, bridge and cross-chain flaws at $1.16 billion, oracle manipulation at $874 million and re-entrancy at $455 million.

Chainalysis reads the same trend from the other direction. Its 2026 report on stolen funds, published in December 2025, puts total crypto theft above $3.4 billion for 2025, with centralized services taking 88 percent of losses in the first quarter and the single Bybit compromise accounting for $1.5 billion. It also notes that DeFi hack losses stayed suppressed through 2024 and 2025 even as value locked in DeFi grew.

Both readings point the same way: contract bugs get caught more often than they used to, and stolen keys don't.

FailureHow it drains fundsPrimary defense
Key and admin compromiseA deployer or signer key is phished or stolen and the attacker calls your own privileged functionsHardware-backed keys, a multisig threshold one laptop cannot meet, a timelock on every privileged path
Access controlAn unguarded privileged function or a callable initializer lets anyone seize admin rightsExplicit roles, guarded initializers, a stable storage layout across proxy versions
Share accountingDonations, rounding and inflation attacks move value between depositors without a transferVirtual shares and a decimals offset, and a rounding direction fixed and tested per operation
Oracle manipulationA flash loan distorts an on-chain spot price, then borrows against the mispriced collateral atomicallyTime-weighted prices, an oracle network with independent reporters, cross-checks that revert on divergence
Re-entrancyAn external call hands control back before state updates finishChecks, effects, interactions, plus a guard on anything touching an external address

A few details in that snapshot are worth remembering. Validator key compromise was the single most expensive technique at $888 million across seven incidents. Improper access control was the costliest bug class at $878 million across 104 incidents, ahead of spot price manipulation at $815 million. Arithmetic and rounding errors still drain protocols even after Solidity 0.8 made overflow revert, because truncating division isn't overflow. And 2026 hasn't been a quiet year: the same capture showed 183 attacks on DeFi protocols through 9 September, worth $1.15 billion.

The broader operational picture, including key custody and the parts of the stack that aren't contracts, sits in our guide to blockchain security.

How much smart contract development costs, and how long it takes

Model, midpoints of the ranges below. Assumes a two-engineer squad and one audit remediation round

Two lines dominate the budget: your engineering, and somebody else's review. The table models the first and quotes published figures for the second. Assumptions, so you can substitute your own: an engineer-week is priced at $4,800, which is forty hours at a $120 blended rate; the scope includes tests, fuzzing harness and deploy scripts, not the front end, indexer or backend around the contract.

ScopeEngineer-weeksBuild cost, modelExternal auditCalendar time
Token or single-purpose contract2 to 4$10k to $19k$5k to $20kAbout a month
DeFi vault or AMM10 to 16$48k to $77k$40k to $100k3 to 4 months
Protocol with governance and upgrades26 to 40$125k to $192k$150k and up6 to 9 months

The audit column comes from Sherlock's 2026 pricing reference, published in February 2026, which puts the market at $5,000 to $250,000 and above, breaks it into those three tiers, and adds $5,000 to $20,000 per remediation pass. It also says most DeFi audits land between $25,000 and $100,000. Budget for at least one remediation pass on top of the base quote, because that's the total worth showing a board.

Competitive audits price differently. On Code4rena the sponsor funds an award pool for the contest, so the lever is how much attention you want to buy, and there's no rate card to compare. Check the sponsor documentation for the current fee terms.

Contract implementation on a vault is a few weeks. The months in the calendar column come from the audit queue, the remediation round and the second look afterwards, so book the audit slot when you write the spec. Don't wait for the code to be finished.

What deploying actually costs on chain

Clients expect gas to be a large line, and it isn't. Putting code on Ethereum costs 200 gas per byte of deployed bytecode, plus 32,000 for the CREATE itself and the 21,000 base cost of the transaction, per the Ethereum execution specs for the Prague rules. A contract at the 24,576-byte ceiling that EIP-170 sets therefore costs roughly 4.97 million gas to deploy.

Ethereum's base fee was 0.10 gwei at block 25,946,617 on 10 September 2026, and ether traded at $2,460 that day. That prices the largest contract the protocol will accept at about $1.22 to deploy. Calldata, initcode and constructor execution add to it, gas prices move, and an L2 costs less again. The order of magnitude holds, though. Deployment costs a few dollars, and the review is where the budget goes.

How to become a smart contract developer

Smart contract development hires for two things: knowing the execution model, and knowing how to attack it. In practice that means Solidity and the EVM first, since gas, storage layout and the call model explain most of what looks arbitrary in the language, then the testing stack, because that is what employers are short of.

Ethereum's learning tools page is the least commercial starting list: Remix for writing contracts in the browser with nothing installed, SpeedrunEthereum for challenge-driven building, and Cyfrin Updraft, which it describes as a free hands-on curriculum for Solidity, security, Foundry and DeFi.

After the tutorials, the fastest progression is unglamorous. Read published audit reports end to end, then rebuild two or three of the findings as failing Foundry tests until the exploit runs locally. The second habit is writing invariants for a protocol you did not build and fuzzing them, which teaches you to read somebody else's code the way an attacker does. Then enter a public competitive audit, where the work is graded by whether you found something real. A smart contract developer who can explain why a rounding direction favors the protocol and prove it with a test is more employable than one who has shipped five tokens.

Choosing a smart contract development company

If you're buying rather than building, ask about how the team works before you look at the portfolio. Ask to see the test suite, specifically the fuzzing and invariant tests rather than unit coverage. Then walk through a past audit with them: what was found, at what severity, and how it was fixed. A team that has never had a serious finding has either been lucky or hasn't shipped much. Key custody is the next question, and the answer should involve multisigs and timelocks rather than a lead developer's wallet. Finish with the one nobody rehearses: what happens at three in the morning when the alerts fire.

Then ask about everything that isn't a contract. Most on-chain products need a front end, an indexer, off-chain signing and a conventional backend, which is the subject of our guide to building a dApp. A vendor who only talks about Solidity leaves you integrating the hard parts. For a wider survey of the market, our list of blockchain development companies sets out how the field is structured, and our DeFi development company guide covers vendor selection for decentralized finance specifically.

What we can show on our side is a mixed record. SeedBox is a crypto venture-investing platform built from the idea stage, with the product requirement document written before the first line of Solidity, contracts written in Solidity with Ethers.js and Web3.js, and the on-chain and off-chain split described above. Zert is an escrow platform where the contract is the referee, with web, mobile and contracts delivered by one squad. Glue is a gold-backed trading platform where we worked the centralized, decentralized and hybrid trade-off in discovery instead of picking a label up front.

And Planetcoin, a crypto exchange platform built around a first-time buyer paying by card, has no smart contracts in it at all, and we left them out on purpose. Shared, verifiable state is a requirement some products have and others don't, and a partner who can't tell you which kind yours is will cost you money. For the market context behind that judgment, our piece on DeFi as a trend is the wider view.

What smart contract development actually demands

Smart contract development rewards teams that treat verification as the deliverable and the code as an intermediate artifact. The patterns are public, the bug classes are documented, the tooling to catch them is mature and mostly free, and the measured loss data says the surviving weak point is increasingly operational rather than syntactic: keys, roles, upgrade paths and who can sign what.

Specify the invariants, keep the contract surface small, build on libraries that have already been attacked, fuzz the properties you wrote down, get a review from people who did not write the code and are not attached to your launch date, and deploy behind a timelock with a pause switch and caps you raise as confidence grows. That is what our blockchain development team does on every engagement. Meet that bar before launch, because after it you can't patch most contracts.

Bring us the spec before the Solidity
We write the invariants, build the contracts on audited libraries, run the fuzzing harness, work the audit findings, and ship the product around them.
Talk to our blockchain engineers

Occasional field notes on building software, no spam

Protected by Cloudflare Turnstile · Privacy · Terms

Artem Zaitsev
Artem ZaitsevCTO · Idealogic Development OÜ

CTO and Co-founder at Idealogic. Directing engineering, systems architecture, security, and full-stack delivery across web, mobile, and blockchain.

Frequently asked questions

  • Smart contract development covers the whole path of an on-chain program: spec, code, tests, audit, deployment and operations. A smart contract is a program stored on a blockchain that runs when its conditions are met, and once it's deployed you usually can't patch it. So most of the effort goes into verification, where ordinary backend work spends it on features.

  • They turn business rules into on-chain code and then attack their own work. Most of the hours go to invariants, fuzzing, static analysis, audit fixes and deployment scripts. Writing the Solidity, Rust or Move is the short part.

  • Budget in two lines: engineering and audit. A single-purpose contract such as a token runs two to four engineer-weeks, a DeFi vault or AMM runs ten to sixteen, and a protocol with governance and upgrades runs twenty-six or more. On the audit side, Sherlock's February 2026 pricing reference puts a simple token at $5,000 to $20,000, a mid-complexity DeFi protocol at $40,000 to $100,000, and enterprise multi-chain systems at $150,000 and up, with each remediation pass adding $5,000 to $20,000 on top. Deployment gas barely registers next to either line, so leave it out of the estimate.

  • Start with Solidity and how the EVM executes it. Free courses such as Cyfrin Updraft and SpeedrunEthereum cover that ground. Then move to security: read real audit reports, reproduce a few exploits in Foundry tests, and enter a competitive audit. Plenty of people can write a contract that compiles, so it's the security work that gets a smart contract developer hired.

  • Escrow. The contract holds the buyer's funds and pays the seller or refunds the buyer once the agreed conditions resolve, with no agent in between. Idealogic built this for Zert. The other common smart contract example is an ERC-20 token, which tracks balances, transfers and spending approvals.

  • A token or single-purpose contract takes two to four engineer-weeks and about a month of calendar time. A DeFi vault or AMM takes ten to sixteen engineer-weeks, and roughly three to four months once you allow for the audit queue and a remediation round. A protocol with governance, upgrade paths and several interacting contracts takes twenty-six weeks or more of engineering and six to nine months of calendar time. The launch date usually depends on when the auditors can start.

  • Solidity, for most projects. It targets the Ethereum Virtual Machine, so one compiled artifact runs on Ethereum, Base, Arbitrum, Optimism and Polygon, and it carries the deepest tooling, library and auditor pool of any option. Vyper is the smaller, deliberately minimal EVM alternative. Off the EVM, Solana programs use Rust with the Anchor framework, and Aptos and Sui use Move.

  • Any contract that will custody value does. Deployed bytecode is public and usually immutable, so an attacker can study it at leisure while you can't patch it. Ethereum's testing documentation is blunt that rigorous testing rarely guarantees the absence of bugs, and names audits and bug bounties as the ways to get other people analyzing your code. One external audit is the floor for a protocol holding funds, and two independent firms is common.

Still unanswered
Ask us directly

A senior engineer replies under 4 hours.

Related expertise