What counts as a single copy
A single copy is anything that exists in exactly one place. That is the whole definition, and it deserves a card because most of the material this map cares about starts as a single copy and stays that way through inattention rather than decision.
Walk the machine in front of you and count. The address string, if it exists only as a bookmark or an open tab, is one copy. A password held only in memory is one copy, and memory has no redundancy and no warning before it fails. A phrase shown once during registration is one copy from the moment the page closes. Key material for a wallet is one copy unless somebody deliberately made another. A generator for a second factor is one copy of a secret.
A place with one copy in it can be dropped, stolen, seized, reformatted, or simply fail on an ordinary morning with no explanation. None of those events are exotic and none announce themselves in advance. The card does not ask you to expect a particular one. It asks whether losing one object takes anything with it that cannot be produced again, and that question has a yes or no answer.
Why this one hangs off the machine you administer
The single arrow arriving here comes from The machine is one you actually control, and what it supplies is the ability to make the second copy at all.
Making a copy means reading something out of one place and writing it into another, and both halves are administrative acts. On a machine somebody else administers, removable storage may be blocked, application data may sit where you cannot reach it, and the only permitted destination may be a store another party runs. There is a subtler version that catches people who have done the work: a second copy inside the same administrative boundary is not a second place. If one console reaches both, one event removes both.
Where the machine is genuinely yours, this card is mostly a matter of noticing. The material is already reachable, and satisfying the condition means moving a little of it somewhere that does not share a fate with the machine.
Four things that die with the device
More of the map rests here than on anything else in this stage. Four cards depend on it directly, and each names an object that has to survive the machine.
The address is kept somewhere that outlives the browser depends on it because a store inside a browser has the browser's lifetime, and a store on one disk has that disk's lifetime. When the machine goes, the address goes with it, and you are back to finding a string wherever strings can be found.
The password exists somewhere outside your head depends on it most literally, because that card restates this one for a specific object. A password kept in memory alone is a single copy of something with no recovery path, and there is no desk on the other end that can be persuaded otherwise.
The recovery phrase is written down before it is wanted depends on it because a phrase shown once is a single copy with a short window in which a second can be made. That card describes the window. This one explains why it matters.
A wallet exists and the keys are yours depends on it because keys held in one place are value held in one place. Holding your own keys means nobody else can move the value. Holding exactly one copy means a single accident moves it beyond everybody, including you.
| Cannot hold | The reason it cannot |
|---|---|
| The address is kept somewhere that outlives the browser | A store sharing a disk with the browser has no life of its own once the disk is gone. |
| The password exists somewhere outside your head | One remembered copy is one copy, and it degrades without notice. |
| The recovery phrase is written down before it is wanted | Material shown once cannot be re-requested, so a lost record is lost permanently. |
| A wallet exists and the keys are yours | Value reachable through one file on one disk fails when that disk does. |
The password and address cards both feed You can log in a second time, and the phrase card feeds You can come back tomorrow and still be you, so a failure here does not stay in this stage. It reappears at both ends of the map.
The order in which the loss is discovered
Nothing goes wrong at the time, which is why the card is easy to walk past. A machine holding one copy of everything works exactly as well as a machine holding two, right up until it stops existing. There is no warning state and no error to read.
The discovery comes later and somewhere else. You are at a different machine, probably for a reason you did not choose. The network is fine. The client is fine. A form asks for a name and a password, and you can produce one of them. What comes back says the details are wrong, which is accurate and points in the wrong direction. It reads as a memory failure, or an account problem, or a change at the other end. It is a copy count that was one, discovered at the only moment the count matters.
Then the second layer arrives. Recovery needs the phrase. The address needs looking up. The wallet needs opening. All three of those lived on the machine. Each is separately survivable and all at once is not, which is the pattern If this is false describes for conditions sitting under several branches.
Naming the list out loud
Say out loud everything you would have to reproduce if the machine in front of you stopped existing in the next minute. Out loud matters, because it forces the list to be finite instead of a general feeling of preparedness. Then name the second place each item lives.
A pass is an item whose second home has a different fate: a different physical place, or at least a different failure. A fail is an item whose second home turns out to be the same disk, the same application or the same account. A fail is also any item where the honest answer is that you would remember it, because memory was already counted as the first copy.
Not a backup routine
This is not a backup policy and names no tool, no medium and no schedule. Backups are about how often copies are refreshed. This card asks only whether a second copy exists at all. It is also not the storage card in the address stage, which concerns where one string lives. How to read a card sets out why the two are separate.