TechSolve

Web3

Code that holds money has to be right the first time.

We write Solidity. Tokens, NFT collections, marketplaces, staking and vaults, DAO governance, bridges, and the dApp front ends that make them usable by people who do not know what a nonce is. The reason to hire a studio rather than a freelancer for this is not the writing — it is everything around it: the test suite, the fuzzing, the review by someone who did not write the contract, the upgrade path decided before launch instead of during an incident, and the honesty to tell you when your idea does not need a blockchain at all.

Zero

undo buttons on a mainnet deploy

This is what makes on-chain work different from everything else we build. A web app with a bug gets patched on Tuesday. A smart contract with a bug is public, permanent, and holding your users' money — and there are bots watching for exactly that mistake, continuously, on every chain. So the process is different too: tests before features, fuzzing and invariant checks rather than happy-path assertions, static analysis in CI, and a rehearsal on testnet that mirrors mainnet down to the deploy script.

What we build

The pieces

Smart contracts in Solidity

The core work. Written against OpenZeppelin where a standard exists, from scratch where it does not, with a test suite that covers the ways it fails and not just the way it works.

Token launches (ERC-20)

Supply, minting rules, vesting schedules, team and treasury allocations, and the liquidity setup. Plus the parts people forget: multisig ownership and a public verified source.

NFTs (ERC-721 and ERC-1155)

Collections with allowlists, phased mints, reveal mechanics, on-chain or IPFS metadata, and ERC-2981 royalties. 1155 when you need semi-fungible editions rather than one-of-ones.

NFT marketplaces

Listings, offers, auctions, escrow and fee splits — either your own contracts or an integration with Seaport, depending on whether owning the venue is actually worth the maintenance.

DeFi primitives

Staking, reward distribution, ERC-4626 vaults, liquidity pools and lending logic. This is the category where an unaudited mistake is most expensive, and we scope it accordingly.

DAOs and governance

Proposal and voting contracts, timelocks, multisig treasuries and delegation. Governance is mostly a social design problem; we will push back on token-weighted voting where it will not work.

Custom EVM chains and L2s

Your own chain or rollup where a shared L2 genuinely does not fit: sequencer, bridge, block explorer, faucet and the RPC infrastructure to keep it up.

Wallets and account abstraction

Connect flows with wagmi, viem and RainbowKit, plus ERC-4337 smart accounts, gas sponsorship and session keys so that users who have never held a seed phrase can still use the thing.

Bridges and cross-chain

Moving assets and messages between chains, built on established messaging layers rather than a hand-rolled relayer, because custom bridges are where the largest losses have happened.

Indexing and subgraphs

Chain data is a write-optimised log, not a database. Subgraphs and indexers turn it into something your front end can query in milliseconds instead of scanning blocks.

dApp front ends

The web app on top: transaction states that explain themselves, gas estimates before signing, pending and failed states handled, and a fallback for when the user's RPC is having a bad day.

Audit preparation

Documentation, invariant specs, coverage and a threat model packaged so an auditor spends their time on your logic rather than on working out what the code is meant to do. It makes the audit cheaper.

Stack

What we work with

Named rather than described, because for this kind of work the names are the qualification.

Languages and standards

SolidityERC-20ERC-721ERC-1155ERC-2981 royaltiesERC-4337 account abstractionERC-4626 vaultsEIP-712 signatures

Contract tooling

FoundryHardhatOpenZeppelinSoladySlitherEchidnaTenderlySafe multisig

Chains

EthereumBaseArbitrumOptimismPolygonBNB ChainAvalanchezkSyncCustom EVM chains

Front end and data

wagmiviemethers.jsRainbowKitWalletConnectThe GraphPonderAlchemy

Storage and metadata

IPFSArweavePinataOn-chain SVGSigned metadata

How we de-risk it

The process that earns the deployment

Everything below happens before anything touches mainnet. It is most of what you are paying a studio for rather than a freelancer.

01

Tests before features

Unit tests, fork tests against real mainnet state, and integration tests through the front end. Coverage is reported, not claimed.

02

Fuzzing and invariants

We state what must always be true — total supply matches the sum of balances, nobody can withdraw more than they deposited — and let a fuzzer spend millions of runs trying to break it.

03

Static analysis in CI

Slither and friends run on every commit. The point is that a reentrancy path or an unchecked return value fails the build rather than reaching a reviewer.

04

Review by someone else

No contract goes out reviewed only by its author. Internal review is a separate pair of eyes with the threat model in hand.

05

We do not audit our own work

An audit by the people who wrote the code is not an audit. We prepare for one, coordinate with the firm you choose, and fix what comes back — but the independent review has to be independent.

06

Upgrades decided up front

Upgradeable or immutable is a decision with real trade-offs, made before deployment. If it is upgradeable, the admin is a multisig with a timelock, not a single hot key.

07

Testnet dress rehearsal

The mainnet deployment runs a script that has already been run end to end on a testnet, with the same parameters and the same verification step.

08

Keys are yours

Deployer and owner keys belong to you, in your multisig, from the first deployment. We do not hold custody of your contracts or your treasury.

Where it works

What people use it for

If one of these is roughly your situation, we have built the shape of it before.

Token launch

An ERC-20 with a vesting schedule the team cannot quietly bypass, verified source on the explorer, and ownership behind a multisig from block one.

NFT collection

Phased mint with allowlist, a reveal that cannot be front-run by reading the metadata early, and royalties that marketplaces will actually honour.

Marketplace or exchange

A venue where people list, bid and settle, with fee splits, escrow and a dispute path that does not require you to hold anyone's assets.

Staking and rewards

Lock, earn and claim, with reward maths that survives someone depositing one wei and someone else depositing the treasury.

Real-world assets

Tokenised property, invoices or commodities, where the hard part is the off-chain custody and legal wrapper rather than the contract.

Loyalty and ticketing

Points, memberships and event tickets as transferable assets — usually with account abstraction, so holders never see a wallet at all.

DAO and treasury

Proposals, voting, delegation and a timelocked treasury, so a compromised signer cannot drain it before anyone notices.

Provenance and supply chain

An auditable record multiple parties can write to without trusting each other. One of the few cases where a shared ledger genuinely beats a shared database.

Pricing

What it costs

Ranges in USD, and they sit above our general rates because this work carries more risk and the people who do it well are scarcer. Third-party audits are separate and paid directly to the firm — budget $15,000 to $60,000+ depending on scope. Gas, RPC and storage costs are yours too.

Contracts

$8,000 – $20,000

2–5 weeks

The on-chain part, written properly and handed over deployed.

  • Solidity contracts for your scope
  • Full test suite with fuzzing
  • Static analysis and internal review
  • Testnet then mainnet deployment
  • Verified source and multisig ownership
Most common

Product

$30,000 – $75,000

8–16 weeks

Contracts plus the application people actually use.

  • Everything in Contracts
  • dApp front end with wallet connect
  • Indexer or subgraph for fast reads
  • Account abstraction where it helps
  • Audit preparation package

Protocol

from $90,000

4–9 months

A system with real money and real adversaries in it.

  • Everything in Product
  • DeFi, marketplace or bridge architecture
  • Custom EVM chain or rollup if needed
  • Audit coordination and remediation
  • Monitoring and incident runbook

Questions

The things people ask

Do we actually need a blockchain for this?

Often, no — and we would rather say so before you spend the budget than after. A blockchain earns its place when several parties who do not trust each other need to write to the same record, when assets must be transferable without your permission, or when the guarantee has to survive your company shutting down. If none of those apply, a normal database is faster, cheaper and easier to change, and we will build you that instead.

Do you audit the contracts you write?

No, and you should be suspicious of anyone who says they do. An audit performed by the team that wrote the code is a code review with a nicer name. We test to exhaustion, run static analysis, and review internally with a second pair of eyes — then we prepare the documentation and invariant specs so an independent firm can audit efficiently, coordinate with whoever you pick, and fix what they find.

What does an audit cost, and do we need one?

Budget $15,000 to $60,000 and above, depending on how much code and how novel it is. Whether you need one is a function of what is at risk: a small NFT collection using a standard implementation is a different proposition from a lending protocol holding deposits. If real money will sit in the contract, the honest answer is yes, and we will scope the build so the audit is as cheap as it can be.

Which chains do you work on?

EVM chains primarily: Ethereum mainnet, and the L2s where most activity now happens — Base, Arbitrum, Optimism, Polygon, zkSync — plus BNB Chain and Avalanche. We also build custom EVM chains and rollups where a shared L2 genuinely does not fit. Chain choice is a scoping conversation, not a preference: it follows your users, your gas budget and where your liquidity already is.

Should our contracts be upgradeable?

It is a trade-off, and the answer depends on what you are building. Upgradeability lets you fix a bug, but it also means someone holds a key that can change the rules — which sophisticated users will notice and hold against you. We decide before deployment, not after an incident. Where we do make contracts upgradeable, the admin is a multisig behind a timelock so that any change is visible before it takes effect.

Who holds the deployer and owner keys?

You do, from the first deployment. Ownership goes to a multisig you control — usually Safe — and we work through it rather than holding custody ourselves. We do not want to be a single point of failure for your treasury, and you should not accept a studio that does.

Can you launch a token for us?

We can build and deploy the contract, set up vesting and distribution, and get it verified and multisig-owned. What we are not is your lawyers: whether your token is a security in a given jurisdiction, what you can say about it, and who you can sell it to are legal questions with real consequences. Get that advice before you write the code, not after — it frequently changes the design.

Do you build the front end as well?

Yes, and it is usually where the difference between a usable product and a demo shows up. Wallet connection, transaction states that explain what is happening, gas estimates before someone signs, handling for pending and failed and dropped transactions, and a sensible fallback when the user's RPC provider is having a bad day.

How do you handle NFT metadata and storage?

Depends on how permanent it needs to be. Fully on-chain, usually as SVG, when the asset must outlive every service involved. IPFS with pinning for most collections, and Arweave when you want to pay once for storage that persists. What we avoid is a single centralised URL, which quietly turns your permanent asset into a broken image the day the bill goes unpaid.

Can users pay gas in something other than the native token?

Yes, with account abstraction. ERC-4337 smart accounts allow gas sponsorship — you pay, and the user does not need to hold ETH at all — plus session keys and social recovery. For consumer products aimed at people who have never used a wallet, this is usually the difference between working and not.

What happens if a vulnerability is found after launch?

That is what the incident runbook is for, and it is written before deployment rather than during the emergency. Depending on the design it means pausing, upgrading through the timelock, or migrating to a new contract — plus monitoring that alerts on the anomaly rather than waiting for someone to notice on social media. We build for that scenario because the alternative is improvising while funds move.

Can you take over a contract another team wrote?

Usually yes, starting with a paid review to establish what is actually deployed, whether the verified source matches, who holds the keys and what the upgrade situation is. Sometimes the finding is that the safest route is a fresh deployment and a migration. We will tell you that even though it is the more expensive answer, because the alternative is building on top of something nobody understands.

Tell us what you want it to do

Describe the job and we’ll come back with a scope, a timeline and a price. We reply within 24 hours, and there’s no charge for the conversation.