Quick Answer: What questions should I ask a blockchain development company before hiring?
Ask a blockchain development company about chain and testnet choices, audit history, upgradeability, token standards, key management, regulatory exposure, gas costs, licensing, and references. The core answer is simple: get written answers to the technical and legal questions before money changes hands, and verify claims against public repositories, audit reports, and past clients. Firms differ widely in specialty, so compare scope, audit partners, upgrade patterns, custody model, jurisdiction, delivery timeline, and post-launch support rather than price alone.
A team that builds DeFi protocols is not the same as one that ships enterprise supply-chain ledgers, and a shop that only writes tokens may never have handled custody. Weigh the answers against your own risk tolerance before committing.
Why These Questions Decide Whether Your Project Sinks or Ships

Picture the moment after launch. The contract holds real money, a bug surfaces, and nobody on your side knows who wrote the upgrade logic. That scenario plays out more often than the industry likes to admit, and almost every version of it traces back to questions nobody asked during procurement.
Blockchain development is unforgiving in a way ordinary software is not. A deployed smart contract can hold funds that move in seconds and cannot be clawed back. Mistakes are public, permanent, and expensive. So the hiring conversation is less about portfolios and more about process: how the team tests, who checks their work, and what happens when something breaks at 3 a.m. on a Sunday.
The questions below are grouped so you can work through them in a single discovery call or spread them across a written questionnaire. Written answers beat verbal ones, because they survive staff turnover and give you something to hold people to.
Chain, Network, and Testnet Questions
Start with the basics. Which blockchain does the team recommend, and why? Ethereum remains the reference point for smart-contract work, and its developer documentation describes public testnets such as Sepolia and Holesky that exist specifically so code can be exercised before it touches mainnet. If a company cannot explain which testnet it will use and what it will test there, that is a warning sign dressed up as a technical detail.
Ask follow-ups:
- Will you deploy to a public testnet before mainnet, and will we get the addresses?
- Do you support layer-2 networks, sidechains, or alternative chains, and what trade-offs come with each?
- How do you handle cross-chain messaging, if at all?
- What is your plan if the target chain changes its fee model or hard-forks?
A useful comparison frame looks like this:
| Question area | Weak answer | Strong answer |
|---|---|---|
| Testnet use | “We test locally” | Named public testnet, deployed addresses, test plan |
| Chain choice | “Ethereum, obviously” | Trade-off analysis of fees, finality, tooling, liquidity |
| Layer 2 | No opinion | Specific rollup or sidechain reasoning tied to your users |
Security, Audits, and Code Review
This is where deals are won and lost. Ask directly: will the contracts be independently audited, by whom, and will we receive the full report rather than a summary? Ethereum’s own security guidance walks through vulnerability classes such as reentrancy, integer issues, and access-control flaws, and it recommends audits and formal verification as mitigations. A serious firm will have a preferred auditor, a budget line for it, and a remediation process for findings.
Watch for three common mistakes. First, teams that treat “we write secure code” as a substitute for a third-party review. Second, audits commissioned after launch, which is like installing brakes after the crash. Third, reports that list findings but never show them resolved.
Also ask whether the team follows a recognized weakness taxonomy. The Smart Contract Weakness Classification registry catalogued known flaw classes with examples, though its maintenance status has been uncertain for some years, so treat it as a reference vocabulary rather than a live standard.
If your project involves AI-driven components or user-facing bots, the security review should extend beyond contracts. The questions in this guide to AI chatbot security before buying are a useful companion checklist for that layer.
Upgradeability, Ownership, and Who Holds the Keys
Ask how the team handles upgradeability, and listen carefully. Upgradeable proxy patterns such as UUPS and Transparent Proxy are well documented in the OpenZeppelin Contracts library, and each carries trade-offs around storage layout, admin privileges, and attack surface. The wrong answer is “we’ll make it upgradeable later.” Retrofitting an upgrade path onto a live contract is painful at best.
Then ask the question that separates amateurs from professionals: who controls the admin keys? Options include a single externally owned account, a multisig, or a timelock plus multisig combination. Each has a cost. A single key is fast and fragile. A multisig is safer but slower. A timelock gives users exit time but complicates emergencies.
Key management deserves its own paragraph in the contract. Guidance on cryptographic key management, such as the NIST SP 800-57 series, treats key lifecycle, storage, and rotation as formal disciplines. Ask where keys live, who can access them, and what happens when a signer leaves the company.
Token Standards and Smart Contract Scope
If a token is in scope, ask which standard applies and why. ERC-20 covers fungible tokens, ERC-721 covers non-fungible tokens, and ERC-1155 handles multi-token contracts. Each has finalized specifications with years of tooling behind them. A team proposing a custom token standard without a compelling reason is asking you to fund their experiment.
Beyond standards, pin down scope in writing:
- Which contracts will be written, and which will be reused from audited libraries?
- What is on-chain versus off-chain, and where does the boundary sit?
- How will gas costs be estimated, and who pays for deployment?
- What documentation ships with the code?
Gas deserves emphasis. The fee market changed with EIP-1559 in August 2021, and costs vary enormously by chain and by design. A firm that cannot sketch your expected per-transaction cost before building is guessing.
Legal, Regulatory, and Licensing Questions
Ask which jurisdictions the company has delivered in and how it handles regulatory exposure. In the EU, the Markets in Crypto-Assets Regulation applies, with stablecoin rules effective from 30 June 2024 and the broader regime from 30 December 2024. If your product touches EU users, that framework shapes design decisions from day one.
Licensing matters too. Ask whether delivered code will be open source, under which license, and who owns the intellectual property. The Open Source Initiative maintains the canonical license list, including MIT, Apache-2.0, and GPL family licenses. A firm that refuses to discuss licensing is often planning to reuse your code elsewhere.
Process, Communication, and Post-Launch Support
Technical depth is necessary but not sufficient. Ask how the team works: sprint cadence, repository access, code review culture, and who your point of contact will be. Request read access to a private repository from day one, not a zip file at the end.
Then ask about the unglamorous parts:
- What is the incident response plan if a vulnerability is found post-launch?
- Who monitors the contracts, and for how long after delivery?
- What does handover look like, including runbooks and key ceremonies?
- What happens if the firm dissolves or a key developer leaves?
Monitoring is not optional. If you are weighing managed security options alongside development, the questions in this managed detection and response checklist translate well to on-chain monitoring arrangements.
How to Verify Claims Before You Sign
Anyone can claim an audit. Verification is your job. Ask for the audit report itself, then check the auditor’s site for a matching entry. Ask for contract addresses from past projects and look them up on a block explorer. Ask for two reference clients and actually call them.
A practical vetting sequence:
- Request the audit report and confirm the auditor published it independently.
- Pull three past contract addresses and inspect the code and transaction history.
- Contact two references, ideally ones whose projects are at least a year old.
- Run a paid discovery phase before committing to full build.
That last point saves more money than any other tactic. A two-to-four week paid discovery sprint, producing an architecture document and a costed plan, lets both sides walk away cheaply if the fit is wrong. Buyers evaluating physical products often learn the same lesson about pre-purchase diligence, as this Rillabox review for buyers shows, and the principle holds for software.
Red Flags That Should End the Conversation
Some answers are disqualifying. A company that cannot name its auditor, refuses to share contract addresses, or promises “military-grade security” without specifics is telling you something. So is a team that quotes a fixed price for an undefined scope, or one that dismisses audits as unnecessary.
Other warning signs are subtler. Vague timelines with no milestones. No written statement of work. Pressure to pay the full amount upfront. A portfolio consisting entirely of tokens that launched and quietly died. Any of these should slow you down; several together should stop you.
What a Realistic Budget and Timeline Looks Like
Ask for a breakdown, not a lump sum. Expect separate lines for discovery, contract development, front-end integration, audit, deployment, and post-launch monitoring. Audits alone often run a meaningful fraction of development cost, and firms that bury that number in a single total are hiding something.
Timelines should be milestone-based, with deliverables tied to payment. A typical structure runs discovery, then core contracts, then integration, then audit and remediation, then deployment. Each stage should end with something you can inspect.
Conclusion
The right questions do not guarantee a good outcome, but they filter out most of the bad ones. Focus on four pillars: how the team tests before mainnet, who independently checks the code, who controls the keys after launch, and what happens when something goes wrong. Get the answers in writing, verify the claims against public records, and insist on a paid discovery phase before the big commitment.
A blockchain project is a long relationship with a short tolerance for error. Ask hard questions early, and the team worth hiring will welcome them. The ones who get defensive were never going to be the right fit.
FAQ
How many blockchain development companies should I evaluate?
Three to five is a workable range. Fewer than three gives you no real comparison, while more than five burns time without adding much signal. Compare written answers to the same questionnaire so responses are directly comparable.
Should I insist on a third-party smart contract audit?
Yes, for any contract that will hold funds or govern access. Budget for it separately and choose the auditor jointly rather than letting the developer pick a friendly reviewer. Confirm the report is published independently so you can verify it later.
What is a reasonable length for a paid discovery phase?
Two to four weeks is typical for a mid-sized project. The output should be an architecture document, a threat model, a costed build plan, and a milestone schedule. If a firm resists a discovery phase, that itself is informative.
Who should control admin keys after launch?
Usually a multisig controlled by multiple parties you trust, often combined with a timelock for non-urgent changes. A single key held by one developer is a single point of failure. Document the signer list and the process for replacing a signer.
How do I check whether a claimed audit is real?
Ask for the report, then look for the same project on the auditor’s own published list. Cross-check contract addresses on a block explorer against the audited commit. If the addresses differ from what was audited, the report does not cover what is live.
What should post-launch support include?
At minimum, monitoring alerts, an incident response plan with named contacts, and a defined support window. Ask for runbooks covering key rotation and emergency pauses. Support that ends at deployment is not support; it is abandonment with a handshake.


