GOVERNANCE SYSTEMS / DAY0
The Emergency Button Is a Governance Product: Designing Pause, Recovery and Accountability in DeFi
A practical operating model for DeFi pause controls, multisig authority, timelocks, recovery states, user communication and post-incident accountability.

A pause function is often reviewed as a line of smart-contract code. In production it is a governance product: someone must detect danger, decide that the threshold has been crossed, execute a bounded action, communicate what changed, preserve user exits where possible, and restore service under a stricter standard than the one used to stop it. If those steps exist only in the team’s memory, the protocol has an emergency primitive but no emergency system.
Six rules before launch
- 01Pause scope should be narrow and explicit.
- 02Detection, decision and execution are separate responsibilities.
- 03Stopping quickly and restarting safely need different authority.
- 04Risk-reducing user actions should remain available where possible.
- 05Every privileged action needs a public reason and durable evidence.
- 06Recovery must be rehearsed, not invented during an incident.
1. Start with actions, not roles
A generic `PAUSER_ROLE` hides the product decision. List the actions that can increase risk: new deposits, borrowing, leverage, swaps, liquidations, bridge messages, oracle updates and treasury movements. Then decide which may be stopped independently and which user actions—repayment, collateral top-up, claim or safe withdrawal—must remain available.
A global halt may be justified for corrupted accounting, but it should not be the only instrument. Market-level and function-level controls reduce blast radius. Dor Arad’s operating principle is to make the smallest change that contains the failure while preserving verifiable user rights.
- Map every control to a named failure mode.
- Specify on-chain events and UI states for each action.
- Test that pausing one market cannot corrupt another.
- Document what remains possible while the protocol is degraded.
2. Separate detection, decision and execution
Monitoring can detect stale prices, abnormal outflows or invariant violations, but an alert is not a governance decision. Define who triages evidence, who is authorised to approve a pause and which account executes it. Separating these stages limits both delay and unilateral power.
Automation can trigger a bounded safety state for objective conditions, such as an invalid oracle observation. Broader judgements may require a multisig. The evidence packet should contain the alert, affected contracts, proposed scope, expected user impact and rollback criteria. That packet becomes the first version of the incident record.
3. Fast stop, deliberate restart
The authority that stops a dangerous action does not automatically need authority to resume it. Pausing is usually reversible containment under uncertainty; unpausing re-exposes user value after the team believes the cause is understood. A stronger quorum, timelock or independent reviewer for recovery can encode that asymmetry.
Timelocks are valuable for routine upgrades because users can inspect pending operations. They can be too slow for containment. A common pattern is a narrowly scoped guardian that can pause quickly, while configuration changes and unpause travel through a governed path. The guardian cannot upgrade implementation, move treasury funds or silently rewrite policy.
4. Design the keys as an operating system
A multisig threshold is not a complete security model. Signers may share devices, geography, employer dependencies or communication channels. Record signer diversity, hardware requirements, transaction simulation, replacement procedure and what happens when one signer is unavailable.
Use distinct accounts for emergency execution, routine administration and treasury. Give each the minimum permissions required. AccessControl-style roles make authority inspectable, while a timelock can become the owner of upgrade and parameter functions. The deployment record should show the full path from human approval to the contract call.
5. Make the degraded state a real user experience
Users need to know which actions are unavailable, which remain safe, and whether their balances are affected. A generic maintenance page is insufficient when repayment still works but borrowing does not. The application should read protocol state, present a timestamped reason and link to the canonical incident update.
APIs and indexers should expose the same typed state as the contracts. Wallet simulations should fail before signature where possible. Support tooling must distinguish a user error from a governed pause. One incident should produce one coherent explanation across contract events, interface, API and communications.
6. Recovery is an evidence gate
Define unpause criteria before launch: root cause identified, exploit path contained, affected balances reconciled, patch reviewed, tests rerun, monitoring active and rollback ready. Not every incident needs a code upgrade; sometimes the correct response is a parameter change or retirement of a market. The evidence must match the action.
Recovery should be staged. Re-enable read paths and risk-reducing actions first, then limited value, then full capacity. Observe each stage against explicit metrics. If conditions degrade, the system returns to the previous safe state without improvisation.
7. Rehearse the complete path
A tabletop exercise should begin with a realistic signal and end with a verified recovery transaction. Measure time to acknowledge, assemble a quorum, simulate, execute, update the UI, notify users and reconcile balances. Rotate unavailable signers and failed RPC providers into the exercise.
Contract tests must prove permissions and state transitions; operational tests must prove that people and tooling can use them. Run at least one drill on every supported network because block explorers, multisig services, gas conditions and finality differ. Store the transcript as launch evidence and turn every delay into an owned improvement.
8. Accountability closes the loop
Every emergency action should publish an on-chain event and a human-readable reason. The post-incident review separates facts from hypotheses, lists user impact, explains privileged actions and records follow-up owners. Transparency does not require exposing sensitive defensive detail while an incident is active; it requires a durable account once disclosure is safe.
The product metric is not simply uptime. Track time to safe state, percentage of protected actions, stranded user value, time to reconciled recovery and recurrence of the same control gap. A protocol earns trust when emergency power is bounded, observable and harder to restore than to invoke casually.
Primary references
The controls described here are architectural patterns, not a universal legal or governance prescription. Contract and operational design should be reviewed for the specific protocol.
- OpenZeppelin Contracts — PausableDeveloper documentation
- OpenZeppelin Contracts — AccessControlDeveloper documentation
- OpenZeppelin Contracts — TimelockControllerDeveloper documentation
- Safe — Smart account and multisig documentationDeveloper documentation
This analysis is educational and does not constitute investment, security or legal advice. Emergency authority should be tailored, audited and tested for the protocol’s actual risk model.