"Should I use a hardware wallet?" is usually answered with a slogan. The slogan is often right, but it isn't a decision method. Developers have an unusual set of risks: we run lots of third-party code, keep keys in config files, deploy contracts with powerful permissions and sign transactions all day. A better question than "which is safer?" is "what am I protecting, from whom, and what does each choice actually stop?".
That is a threat model, and it fits on one page. I'll walk through one for a developer, show where each wallet type helps, and end with a practical way to split your wallets by role. I haven't tested any hardware wallet for this post, so what I say about devices comes from the vendors' own documentation and is attributed to them.
Definitions, briefly
- Hot wallet. Keys live on an internet-connected device: a browser extension, a mobile app or a key in a config file. Convenient, and exposed to whatever else runs on that device.
- Hardware wallet. A dedicated device that holds the keys and signs transactions internally, so the keys don't leave it. You confirm each action on the device's own screen. Ledger describes its devices as keeping private keys offline and showing a "Secure Screen" for review.
- Multisig. A contract wallet that needs several approvals from different keys. It's not an alternative to the others, but a layer on top.
Step 1: what are you protecting?
Write the list. For a typical developer it looks like this:
- Savings and long-term holdings. High value, rarely used.
- Deployer and owner keys for contracts. These may control a project's funds or upgrade rights. Their value is the value of what they control.
- Day-to-day spending and testing funds. Low value, used constantly.
- API keys and RPC keys. Not funds, but they can cost money and expose data.
Different assets deserve different protection. The mistake is treating them as one pile in one wallet.
Step 2: who is attacking, and how?
- Malware on your computer. A keylogger, clipboard hijacker or malicious browser extension. Developers face a bigger risk here, because we install packages and run unfamiliar code all the time.
- Phishing and malicious dApps. A site that gets you to sign an approval or transfer you didn't understand. This works regardless of wallet type, because you are the one signing.
- Supply-chain attacks. A compromised dependency that reads environment variables or config files, where private keys often sit.
- Social engineering. Fake support staff, fake job offers with a "test project" to run, fake investors.
- Address poisoning. An attacker sends a tiny transaction from an address that looks like one you use, hoping you'll copy it from your history. Trezor's support page describes it, and advises never copying destinations from transaction history.
- Physical loss or theft. Of the device, or of the backup phrase.
- Insiders and shared keys. Anyone with access to a shared deployer key.
Step 3: what each setup actually stops
| Threat | Hot wallet | Hardware wallet |
|---|---|---|
| Malware stealing the key from your computer | Can succeed. The key is on the machine. | Much harder: the key is not on the computer, and signing happens on the device. |
| You sign a malicious approval | Succeeds, if you confirm it. | Still succeeds if you confirm it. The device only protects the key, not your judgment. |
| A compromised website shows you one thing and sends another | Possible if you trust the on-screen prompt. | Better, if the device can display the real details. Ledger says a malicious site can make the software layer display a transaction that does not match what will be signed, which is why it shows details on the device screen. |
| Unreadable data on the device screen | Not applicable. | Ledger's own docs call approving unreadable data "blind signing" and say it's where phishing does its damage. If the device can't decode a transaction, you are back to trusting the website. |
| Address poisoning | Succeeds if you copy from history. | Same. Verify the address on the device screen, from a source you trust. |
| Loss of the device or phrase | Same exposure for the phrase. | The phrase backup is still the master key. Anyone who has it controls the funds. |
The honest summary: a hardware wallet protects your key from your computer. It doesn't protect you from signing something bad. For a developer whose main risk is a compromised laptop or dependency, that protection is valuable. For someone whose main risk is being tricked, the thing that helps most is slowing down and reading what you sign.
Step 4: split your wallets by role
This is the most practical outcome of the exercise. A setup that I'd consider sensible for a developer:
- Savings wallet (hardware). Used rarely. It never connects to experimental dApps and never signs approvals for unfamiliar contracts.
- Operations wallet (hardware, or a multisig built from hardware keys). Owns deployed contracts and admin rights. Use a multisig for anything that holds user funds, so no single key, person or laptop can move it. See the deployment checklist for where this fits in a launch.
- Everyday hot wallet. Small balance, used for interacting with new apps. Assume it can be lost, and fund it only with what you're willing to lose. Revoke its approvals regularly (see token approvals).
- Throwaway test wallet. For testnets and local development only. Hardhat's documentation tells you to make sure the key used for Sepolia is only for testnets, with no valuable assets. Treat any key in a config file or environment variable as compromised-in-waiting.
Developer-specific hygiene
- Keep keys out of the repository and out of plain config. Hardhat 3's
configVariablereads values from the environment or its encrypted keystore. The keystore is better than a.envfile because it isn't plaintext, though it still sits on the machine you're protecting. - Separate machines or profiles. Use a clean browser profile, with few extensions, for anything involving a wallet. Don't run unknown repositories on the machine that has your wallet extension.
- Be careful with "test tasks" from strangers. Running an unfamiliar project on your main machine executes its code with your permissions.
- Pin and review dependencies. A lockfile and a habit of looking at what changed before you update reduces supply-chain risk. It doesn't remove it.
- Back up the recovery phrase offline and test the recovery with a small amount before trusting it. Never photograph it or store it in cloud notes.
- Verify on the device. Check the recipient address and amount on the hardware screen, not just in the browser.
When a hardware wallet isn't worth it
If your holdings are small and you're mainly learning, the cost and friction might not be justified yet. A fresh hot wallet with a small balance, careful signing and regular approval cleanup covers the main risks for that scale. The calculation changes the moment real value or other people's money is involved. And if you're running a project, the answer is almost always "multisig with hardware signers" for admin rights, regardless of your personal preferences.
A one-page threat model you can copy
- List your assets and what each is worth.
- For each, list the likely attacks: malware, phishing, supply chain, social engineering, loss.
- For each attack, note whether your setup stops it, and be honest about "no".
- Assign each asset to a wallet role, with the strongest protection for the highest value.
- Write down your recovery plan: who has the backups, and what happens if you're unavailable?
- Review it every time your holdings or tools change.
Setting up deployment keys for a project?
I help teams set up deployment pipelines with multisig ownership, testnet rehearsals and sensible key handling. Get in touch if you'd like a hand.
See services Get in touchWhat I ran this against
- I did not test any hardware wallet or hot wallet for this post. Vendor statements about devices and features come from the vendors' own documentation, listed under Sources, and are attributed to them. I make no product recommendation.
- The Hardhat configuration facts (
configVariable, the encrypted keystore and the advice to use a testnet-only key) come from the Hardhat 3 documentation and my own test of the config in the verification post, not from a hardware-wallet test. - This is education, not financial or security advice. I'm a developer describing how these tools work; I can't see your situation, and you remain responsible for what you sign.
Sources checked
- Ledger, "Clear Signing overview" (describes blind signing, the claim that a hardware signer's screen shows what you sign, and the limits of simulation and ABIs): developers.ledger.com. Vendor documentation; claims are the vendor's.
- Ledger Academy, "What is Ledger Wallet direct access?" (the software layer runs online, and a malicious site can make it display a transaction that does not match what will be signed): ledger.com/academy. Vendor documentation.
- Trezor support, "What are address poisoning attacks and how to avoid them": trezor.io. Vendor documentation.
- Hardhat 3 documentation, deployment overview (the keystore plugin stores secrets in an encrypted vault, and the Sepolia key should only be used for testnets): hardhat.org/docs/guides/deployment.