An audit is a professional code review. It reduces risk; it does not remove it. The most dangerous sentence in this industry is "we got audited," because it converts a finite piece of work into a feeling of safety, and the exploits that emptied the largest treasuries happened to contracts that had been reviewed.
So the useful question is not whether to get audited — you will — but what the report actually covers, what it structurally cannot, and what you do afterwards.
What an audit examines, and what it does not
Auditors look at the code as written: reentrancy, access control, arithmetic, unchecked external calls, upgrade and initialisation paths, and the gap between what the comments claim and what the functions do. Good firms also reason about economic assumptions — whether the invariant the protocol depends on can be broken by manipulating a price feed.
What no review catches by reading code: a keeper that stops being profitable, an oracle that reports a stale price during a quiet weekend, a governance proposal that is technically valid and financially catastrophic, or a key held by one person in a browser. Those are the failure modes that produce most losses, and they live outside the diff.
The boundary is worth stating plainly, because teams keep buying audits to cover things audits cannot see. An audit is a snapshot: one version of the code, reviewed for weeks, against everything known at that moment. It is silent about the next upgrade, the new integration added after delivery, and the operational state of the deployment — who holds keys, what the multisig threshold is, whether the pause function has ever been tested. Any security claim built only on an audit is a claim about the past.
The process, and the part people skip
The engagement is short; the preparation is where the value is created. Before you approach anyone, freeze the code, delete dead paths, and write down the invariants you believe hold. Auditors who spend their first day reconstructing your intent bill you for it and find less.
The preparation document takes an afternoon and repays itself for the life of the protocol:
- The invariants, each one a sentence: "total shares always equal deposits minus withdrawals," "no user can withdraw more than they deposited," "the pause role cannot mint."
- The trust map: every external dependency the code trusts — oracles, bridges, tokens with fees or rebasing behaviour — and what happens to your protocol when each misbehaves.
- The known rough edges: the parts you already suspect. Pointing auditors at your doubts is not self-incrimination; it is the highest-leverage thing a review client can do.
Then decide your mix. Private firms give depth and a relationship; competitive audits on platforms like Code4rena and Sherlock give many more eyes per dollar, which on a large codebase usually finds more. Both is not extravagant — it is the standard for anything holding real funds.
Severity labels are a triage system, not a score. Critical and High findings are fund-loss or protocol-breaking; Medium usually means a broken assumption under specific conditions; Low and informational are housekeeping. What matters is the disposition of each item: fixed, acknowledged, or disputed with a reason. An acknowledged-and-unfixed High is a decision, and it should be visible to your users rather than buried in an appendix.
Reading the severity flow concretely: say the report lists one Critical (a reentrancy vector in the withdrawal path), two High (an upgrade path that skips the timelock; a fee parameter the owner can set to 100%), and a Medium (a rounding direction that favours the protocol by dust amounts). The work after delivery is a table, not a vibe: the Critical gets fixed and re-reviewed before deployment, always. Each High gets a written disposition — "fixed in commit X," "accepted because the owner key is behind a four-of-seven multisig with a timelock," "disputed because the parameter cannot be set without a governance quorum." The Medium gets fixed when convenient or documented as dust-level by design. A report where every finding ends in "fixed" without commit references is paperwork; a report where every ending is a visible, reasoned decision is a security programme.
Cost, and preparing for the questions
Budget 15-25% of development cost for security across audits, bounties, and monitoring. Projects that cut here pay for it later at a worse exchange rate.
Timelines run four to six weeks for a private engagement on a moderate codebase — preparation before, remediation after — and a competitive contest compresses the review itself into one or two weeks while adding a judging period. Plans that schedule launch the week the audit ends have already decided the audit is a stamp; the remediation window is part of the audit, and it is the part that fixes things.
When choosing an auditor, ask what they found on the last audit they did for a protocol structured like yours, and who reviewed their own work. Red flags: a fixed price quoted without reading the code, delivery measured in days for a novel system, a report that lists findings without explaining exploitability.
After the report lands
A signed-off audit is the beginning of a security programme, not the end of one. The layers that continue working: formal verification for the invariants that must never break, a bug bounty that pays enough that disclosure beats exploitation, monitoring that can pause the contracts when an invariant breaks, and an incident-response plan you have rehearsed rather than written.
The bounty deserves the same arithmetic as the audit. A bounty that pays less than a profitable exploit pays out is a bounty on paper; disclosure competes with crime, and crime has better margins. Sizing guidance and the mechanics of running one are covered in White Hat Hacking 101.
Monitoring closes the loop that static review cannot: the on-chain watchers that page a human when an invariant bends are the difference between a bad afternoon and a post-mortem. And the response plan is only real if it has been walked through — who pauses, who communicates, who calls the bridge's emergency contact — at least once with the actual people, before the actual night it is needed.
Consider how you handle the audit report itself. Publishing the findings, including the ones you judged acceptable, is how readers learn to trust the parts you got right.
References
Next, read White Hat Hacking 101 for the incentive layer that continues after the audit. More in Security & Privacy.