Your audit is closed, but is your protocol covered? Learn how to run a bug bounty program after your audit: set severity tiers and payouts against funds at risk, choose between Immunefi, Sherlock, Cantina, and CodeHawks, write scope and safe harbor rules, build a triage workflow, and keep scope current as new exploit patterns emerge

Your audit is closed, but is your protocol covered? Learn how to run a bug bounty program after your audit: set severity tiers and payouts against funds at risk, choose between Immunefi, Sherlock, Cantina, and CodeHawks, write scope and safe harbor rules, build a triage workflow, and keep scope current as new exploit patterns emerge
Your audit report is closed, the fixes are merged, and the contracts are live. Here's how to run a bug bounty program that actually catches what the audit couldn't: severity tiers and payout sizing, where to host the program now that Code4rena is gone, scope rules that survive researchers trying to game them, and a triage workflow your team can sustain past week one.
A bug bounty program is not a substitute for an audit, and launching one before your deployment hardening is finished wastes researcher attention on bugs a reviewer would have caught for a flat fee. QuillAudits has already laid out that decision in detail in Bug Bounty vs Audit: What Your Protocol Actually Needs, so this post assumes you've made the call and are past it.
Before you open submissions, confirm the basics are actually done, not just planned:
Even a clean audit doesn't make a bounty redundant. Recent industry analysis cited in QuillAudits' Continuous Security: Why a One-Time Audit Isn't Enough found that audited applications still accounted for roughly 10.8% of exploit losses, with audited protocols including Balancer (around $120 million) and Cetus (around $223 million) among the victims. An audit is a snapshot of the code at one point in time; a bounty is a standing incentive for someone to keep looking after that snapshot is out of date. A Critical-tier payout capped at roughly 10% of funds at risk looks expensive on a quiet month with no reports, but it's cheap next to losing all of those funds in a single exploit, which is the actual ROI case for running a bounty instead of treating the audit as the finish line.
Figuring out how to set up a bug bounty program usually starts with two decisions researchers read first: severity tiers and payout sizes. Getting them wrong either attracts nobody serious or burns your treasury on low-impact reports. The table below maps the four-tier classification most Web3 programs now use, adapted from Immunefi's Vulnerability Severity Classification System, against what each tier should actually pay.
| Severity | Smart contract example | Typical impact | Payout approach |
|---|---|---|---|
| Critical | Direct theft of user funds, permanent freezing of funds, unauthorized minting, protocol insolvency | Funds gone or permanently locked | Up to 10% of funds directly at risk, program-specific maximum |
| High | Theft or loss of unclaimed yield, temporary freezing of funds | Recoverable, but still financial loss | Fixed range, often tens of thousands of dollars |
| Medium | Griefing, unbounded gas consumption, disruption without direct loss | Protocol unusable or degraded, no funds lost | Smaller fixed range |
| Low | Issues with no value at risk | Theoretical or cosmetic | Flat, modest reward |
Immunefi's Vulnerability Severity Classification System v2.3 defines separate scales for smart contracts and for websites or applications, since a wallet-draining bug and a broken frontend form carry very different stakes, and it is the de facto standard most Web3 programs now inherit rather than invent their own. On the smart contract scale, Critical covers direct theft of user funds, permanent freezing of funds, unauthorized minting, and protocol insolvency; High covers losses that are recoverable or temporary, such as theft of unclaimed yield; Medium covers disruption without direct loss, including unbounded gas consumption and griefing; and Low covers issues with no value at risk at all.
If your audit report already uses a Critical-through-Informational scale, like the one QuillAudits documents in What's Inside a Smart Contract Audit Report, map it directly onto this tier system. A finding your auditor flagged as Critical should carry the same bar as a Critical bounty submission; don't invent a looser definition just because the researcher is a stranger instead of a firm you hired.
Work backward from your own treasury's worst case. If a single exploit could drain $50 million, a 10%-of-funds-at-risk Critical tier implies a maximum payout near $5 million, capped by whatever ceiling your treasury can actually absorb. Don't set Medium and Low rewards as an afterthought either: if they're too small relative to the effort of writing a clean report, researchers skip past your program toward one that pays for the same hour of work.
Launching a Web3 bug bounty program today means picking from four platforms worth evaluating directly: Immunefi, Sherlock, Cantina, and CodeHawks.
Each of these fits a different shape of engagement, and conflating them leads teams to pick the wrong one for their stage:
If your goal is the standing, always-on program this post describes, Immunefi or Sherlock are the more direct fits; Cantina and CodeHawks lean toward contest-style engagements you'd run alongside, not instead of, a long-running bounty.
A platform-hosted program gets you an existing researcher pool, standardized severity language, and usually some triage support, in exchange for a fee on payouts and less control over disclosure timing. A self-hosted program, where you publish scope and rules on your own site or GitHub and manage submissions through a dedicated email or form, gives you full control but means building your own researcher reach, reputation, and triage tooling from zero.
For most teams past their first audit, a platform-managed program is the more defensible default: researchers already trust the platform's escrow and dispute process, and you're not asking a stranger to wire a Critical-tier payout on a handshake. Self-hosting makes more sense for protocols with an existing, named community of trusted contributors who don't need a platform's reach to find the program.
Loose scope language is the fastest way to turn a bounty program into a support queue. Two things need to be airtight before launch: exactly what's in scope, and exactly what protection a researcher gets for reporting in good faith.
List in-scope targets by exact contract address and chain, not by product name, since "the staking contract" can mean three different deployments by the time a researcher reads your page. For each target, state the maximum severity it's eligible for; a frontend repo, for instance, should never be eligible for a Critical smart-contract payout even if a bug there is embarrassing. Explicitly list what's out of scope too: known issues already disclosed in your audit report, third-party dependencies you don't control, and anything in the audit's "accepted risk" section, since silence invites a researcher to argue a known, accepted tradeoff is a new finding.
Is a bug bounty program legal to run, and is a researcher who finds a Critical bug legally protected for reporting it? That depends entirely on the policy language you publish, not on the existence of the bounty itself.
Duplicate reports are the other recurring fight. State upfront that payouts go to the first valid report by timestamp, that near-simultaneous reports of the same root cause are treated as duplicates regardless of how differently they're worded, and that your triage team's root-cause determination is final. Publishing this before launch, rather than improvising it during your first dispute, is what keeps a disagreement from turning into a public argument on social media.
A severity scale and a safe harbor policy only matter if someone reads the reports promptly. Triage is the part of running a bounty that most teams underbuild, because it looks like paperwork until a Critical report sits unread for four days.
Commit to a first-response service-level agreement, acknowledgment within 24 to 48 hours for any report, regardless of eventual severity, and hold yourself to it publicly. Name a single owner for triage, not a channel. A Slack channel that "someone" monitors is how a Critical report sits unread over a weekend; a named engineer or security lead with triage as an explicit responsibility is how it doesn't. If you're running on Immunefi or Sherlock, use the platform's own triage layer to pre-screen obvious duplicates and out-of-scope submissions before they reach your team, but don't treat platform triage as a substitute for your own technical review of anything that clears that first filter.
A Critical finding needs a path that skips your normal review queue entirely. Define, in writing, who can authorize an emergency pause or upgrade on a live contract, how fast that person can be reached outside business hours, and what the researcher should expect to hear back and when, since a researcher who hears nothing for 72 hours after reporting a live fund-draining bug has every reason to assume you're not taking it seriously, and some will act on that assumption. Keep this escalation path separate from your Slack-channel owner for routine Medium and Low reports; conflating the two means a routine report can bury a Critical one in the same inbox.
Here's the catch: a bounty program frozen at launch-day scope goes stale fast, because attackers don't stop inventing new patterns just because your rules page does. The pace of the problem is real. April 2026 alone saw nearly 30 major Web3 security incidents, draining over $600 million, as part of a broader surge that compromised $16.521 billion in total value globally and $7.741 billion in DeFi specifically. A static scope document from your launch month has no mechanism for catching whatever exploit class defined last month's headlines.
The fix is to treat your bounty's scope and severity definitions as a living document, not a one-time publication, and QuillAudits' own hack-analysis coverage is a direct, free input for that update cycle. Each new post-mortem QuillAudits publishes, cross-posted at its research hub, names a specific root cause, whether it's a reentrancy path, an oracle manipulation vector, or a signature-scheme weakness like the threshold signature flaws behind recent cross-chain incidents. Run a recurring review, quarterly at minimum, asking two questions against that stream: does our in-scope code contain this same pattern, and does our severity table already cover it at the right tier? A new class of oracle manipulation that drained a comparable protocol last month belongs in your scope notes this month, not after it happens to you too. The bounty programs that stay useful past their first year are the ones treated as a maintained control, checked against live incidents, not a page nobody has opened since launch.
A bug bounty program earns its keep by staying funded, clearly scoped, and genuinely monitored long after launch day, not by existing as a line item on your security page. Size payouts against real funds at risk, pick a platform that matches how your program actually runs, publish safe harbor language before your first report arrives, and name a human who owns triage. Protocols weighing how a bounty fits alongside an audit and ongoing monitoring can start with QuillAudits' Bug Bounty vs Audit comparison and its continuous security framework for what else belongs in that rotation.
Contents

From day-zero risk mapping to exchange-ready audits, QuillAudits helps projects grow with confidence. Smart contracts, dApps, infrastructure, compliance: secured end to end.