How to Create a Strong Password That You Can Also Remember

The short answer

A strong password is one that is long, unpredictable to a machine, and not used anywhere else. Those three properties are independent of each other, and most advice focuses on the middle one while people actually fail on the third.

For a secret you type from memory, prefer a passphrase: several unrelated words joined by a separator, which is easier to recall than the same amount of randomness dressed up as symbols. For everything you do not want to remember, generate a long random string with a character-set generator and let a password manager store it. If you only take one rule away: never use the same password on two sites.

• Length first. Every character you add multiplies the guessing space by the size of your character pool.
• Uniqueness second. One breached site must not be able to unlock a second one.
• Memorability third, and only for the few passwords you type by hand — that is what passphrases and managers solve.
• Symbols are the least valuable of the three ingredients, and they are the reason most weak passwords look complicated.

Entropy, in plain terms

Guessing a password is a search through a space of possibilities. Two things set the size of that space: how many characters you are allowed to choose from, and how many characters you actually use. The first is the pool size. Lowercase letters give a pool of 26; adding uppercase gives 52; adding digits gives 62; and the eight symbols offered by the generator on this site (!@#$%^&*) bring the total to 70.

The standard way to express the result is bits. Each character you add contributes log2(poolSize) bits, so the estimate is bits = length × log2(poolSize). A bit is a doubling: one extra bit makes the space twice as large, so twenty extra bits make it about a million times larger. That exponential growth is the whole reason length matters so much more than any formatting rule.

Work one example yourself. With a 70-character pool, one character contributes 6.13 bits, so a 16-character password comes to roughly 98 bits. The same pool at 8 characters gives about 49 bits. The 16-character version is not twice as hard to guess: the gap between them is about 49 bits, which is a factor of roughly 576 trillion. This is exactly what the generator's strength bands are measuring — fewer than about 38 bits reads as Weak, 38 to 67 as Medium, and 68 or more as Strong.

One honest caveat about the formula. It assumes every character is chosen independently and uniformly from the full pool, which is what a computer does and what a human typing at a keyboard emphatically does not. Human choices concentrate in the first character, in dictionary words, in left-hand keyboard rows and in dates. Real entropy is what an attacker cannot predict, and a rule-based estimate is the best anyone can do before seeing the password.

Why length beats symbol soup

The classic requirement — one uppercase, one digit, one symbol, at least eight characters — pushes people toward templates rather than randomness. Faced with a rule, a human satisfies it in the most memorable way available: capitalise the first letter, append a year, put a symbol at the end or swapped in for a letter. The result has the shape of a strong password and the guessing difficulty of a weak one, because the attack space is not the full pool but the narrow set of patterns people actually use.

Compare the two directly. Twelve lowercase letters chosen at random come to about 56 bits, since each letter contributes 4.70 bits. Eight characters drawn from the generator's 70-character pool come to about 49 bits. The lowercase string has no capitals, no digits and no symbols at all, and it is still the stronger of the two: twelve letters give 26^12 possibilities, roughly 95 quadrillion, while eight mixed characters give 70^8, roughly 576 trillion.

This is why the good advice inverts the way most people expect. If you want symbols, use them; but if you have to choose between forcing in a character class and adding two more characters, add the characters. Substitution tricks are worse than useless: Tr0ub4dor-style rewrites are a known convention, and every guessing tool that bothers to try one tries exactly that one.

The multiplication rule is worth stating plainly so you can check any claim you read: doubling the length squares the search space. Going from 8 to 16 characters from the same pool doubles the bit count, and each additional character multiplies the space by the pool size.

Is 8 characters enough?

Eight is a floor, not a target. It is the minimum most sites once demanded, and people treated the minimum as if it were the recommendation. Nothing about eight characters makes a password safe; it merely stops it from being rejected by a form.

What eight characters are worth depends entirely on how they were built. Eight truly random characters from a 70-character pool give about 49 bits, which the generator itself labels Medium. Eight random lowercase characters give about 38 bits, right at the line between Weak and Medium. Eight characters typed by a human — a name plus a year, a keyboard run, a word with letters swapped for digits — carry far less than either figure, because the space the attacker searches is the space of human habits, not the space of the alphabet.

So when a site asks for at least 8 characters, treat it as the site telling you its minimum, and then set your own floor higher. If you are typing the password from memory, aim at sixteen random characters or five to seven unrelated words, which is the range that stays both hard to guess and reproducible. If a manager is typing it, go longer — the generator on this site accepts lengths from 8 up to 64, and there is no reason to sit at the bottom of that range for an account you never type by hand.

Passphrases: the password you can actually remember

A passphrase is a sequence of unrelated words used as a password. It wins on the memory problem because human memory handles images well and random symbol strings badly, and it wins on the arithmetic because each word slot contributes a lot of bits. The passphrase page's own retention advice is to keep the generated lines whose words you can picture, and to stage them in your head as a short scene.

The passphrase generator on this site picks from a built-in list of 1,143 common English words with crypto.getRandomValues and rejection sampling, so every word in the list has exactly equal probability. Each slot therefore adds about 10.2 bits. Word count is the dial that matters: four words land near 41 bits, six words around 61, seven around 71, and eight near 81. Six is the default on the page, and seven is the sensible choice for a secret you will actually have to recall, because one extra word barely changes what you memorise while it multiplies the guessing space by the size of the whole word list.

Separators and capitalisation

The page offers a hyphen (the default), a space, a middle dot, or no separator at all, plus lowercase or Title Case. The separator is what keeps the string reproducible, so the honest advice is to keep one; with the no-separator option the page forces Title Case so the word boundaries remain visible when you type it back in.

Be clear about what capitalisation buys. Starting each word with a capital letter is one extra decision per word, and an attacker who has decided to try capitalised word lists knows to try it. It is worth a little, not much. The bit count that matters comes from how many words you have and how large the word list is.

There is a related trap worth naming: a passphrase is only as random as the words in it. Names of family members, song lyrics, common proverbs and book titles are all drawn from a much smaller pool than a shuffled word list, so a personally meaningful six-word phrase can be worth far less than the six words generated from a 1,143-entry list.

Digits and symbols on the end

The generator has optional switches to append a number and a symbol, joined with the same separator. The number is a value from 0 to 99, which adds about 6.6 bits; the symbol is one character drawn from the page's 25-character list, worth about 4.6 bits. Turned on together with six words, that takes you from roughly 61 bits to roughly 72.

That is real, and it is also cheap for an attacker to model. Appended digits are one of the most predictable structures in password guessing, so treat these switches as decoration for sites that demand a number or a symbol rather than as the source of strength. Add a word instead of a digit when the site lets you, and check whether the requirement is even enforced before you pay the memory cost of meeting it.

The memorised-anchor method, and its real cost

If you refuse to use a manager, the method people converge on is an anchor: a base secret you memorise, plus a part derived from the site. Mentally, it looks like your anchor word, then something specific to that site such as its initials, then a digit and a symbol. The structure is the point — you memorise one string and derive the rest, so each site gets a different password and you can rebuild any of them from memory.

Describe it accurately and it is a compromise, not a recommendation. It fails in two specific ways. First, the derived part has a small space: if your variation is site initials plus one digit, an attacker who has recovered your anchor from one breach can enumerate that variation exhaustively, rather than searching the alphabet at all. Second, and worse, one exposed password is a hint about the rest. A base pattern recovered from a breach — from a shoulder-surfed keyboard, a keylogger, or an old password someone else remembers — is a template for every other account you own.

Two habits reduce the damage if you use it anyway. Derive the per-site part from something only you know — a short per-site code you keep written down separately — rather than from the site's name or its top-level domain, which any attacker can see. And keep the anchor method away from your email, your bank, and the account that can reset the password for everything else: those three are worth memorising properly, or worth putting in a manager.

Password managers: the actual answer to remembering

A manager solves the part of this problem you cannot solve with cleverness: holding many long, unique, unrelated secrets so that remembering them is not your job. Every manager does three things. It generates a random password of the length and character sets you choose. It stores that password encrypted against the site's address. It fills the login form for you, so you never type or read the secret.

That changes what you memorise. Instead of twenty weak-but-recallable passwords, you keep one strong one — the vault's master password — and the other nineteen become strings you never see. This is exactly the case where a passphrase is the right shape: the passphrase generator's own guidance is five to seven words plus a separator for a master password, which is both reproducible under pressure and expensive to guess. Type it into your manager once to confirm you remember it, then discard the generated copy.

Google Password Manager is one of the options here, and it does what any manager does: it generates, stores and autofills passwords for the Google account you are signed in with. Choosing between managers is a question of convenience and of where you want your vault to live, because the generate-store-autofill job is the same whichever you pick: dedicated manager apps, browser password features and operating-system keychains all do it. Whichever you pick, the security property you are buying is uniqueness, not storage.

One distinction worth keeping straight: a passkey is not a password. A passkey is a public-key credential stored on your device and registered with a website, with nothing to memorise — the login mechanism a passphrase is compared to on the passphrase generator's own page. Passkeys are the better option where a site supports them; a passphrase stays the right tool for the master password and for anywhere you still have to type a secret.

Reuse is the failure that actually gets people

The reason uniqueness outranks complexity is how breaches get exploited. When a site is compromised, its password list leaks and gets tested against other sites — the same email and the same password, tried at banks, stores and mail providers by automated tooling. This works only because people repeat passwords, and it works quickly, since the attacker does not have to guess anything: they already have the correct string, they just do not know which other accounts accept it.

The goal, then, is that one breached site should not unlock another. Unique passwords achieve that on their own: a leaked credential for the shop is a leaked credential for the shop and nothing else. No amount of symbol complexity does the same job — a superstrong password reused everywhere is exactly as bad as a weak one reused everywhere, and probably worse, since the owner feels safe.

Uniqueness is a property you have to enforce yourself, and generating a fresh random string for every account is the practical way to do it — which is why generators and managers are usually discussed in the same breath. Two supporting habits matter: turn on two-factor authentication on the accounts that can lock you out of anything else, and be careful with password reset routes, since your email inbox is the master key to most of your other accounts and it is the one place reuse hurts twice.

What a generator cannot do for you

Generators are honest tools with a narrow job, and the advice surrounding them usually implies more. Four limits are worth knowing before you trust a green strength bar.

It does not know whether your password has already appeared in a breach. A generator picks a string from a character pool; it holds no list of leaked credentials, compares nothing against one, and cannot tell you that a password was exposed somewhere else. A string can be perfectly random and still be worthless if the site storing it is compromised, which is why the defence is uniqueness rather than a better-looking password.

It does not read passwords the way a good strength meter does. The strength readout on the character generator is its own entropy estimate from length and character-set variety, not a pattern analyser: it does not look up dictionary words, recognise keyboard runs, test common substitutions, or model how a real cracking tool would order its guesses. Strength meters built for that purpose, zxcvbn being the best-known, routinely rate a password the entropy arithmetic calls Strong as one an educated guesser would find fast. They are measuring different things, and the disagreement is informative rather than a bug.

It cannot protect you from phishing. A unique, random, 64-character password typed into a convincing fake login page has been handed over, and the attacker now holds the same secret you do and can log in as you. No generator, strength meter or manager setting makes a password resistant to that; the defence is checking the address before you type anything, and letting autofill do the typing where it can, since a manager only offers a saved credential for the address it was saved against.

And it does not remember anything for you. The character generator on this site writes nothing to storage, keeps no history, and offers no export: close the tab and the passwords on screen are gone. That is the right design for a page about secrets, and it is also the reason generation is half of the workflow — a generated password you cannot retrieve is a generated password you will end up reusing.

Putting it together

For accounts the manager controls: open the generator, set a length of 20 or more rather than the minimum of 8, enable the character sets you want, and save the result straight into the manager instead of writing it down anywhere. Internally it puts at least one character from every enabled set into each password, then shuffles the whole string with a Fisher–Yates shuffle driven by the same crypto random source. Batches top out at 20 passwords per run. If a site rejects the symbols, generate again without them rather than editing the string by hand — a hand-edited password is a partly human password again. On the ambiguity switch, know the trade: with all four character sets selected, excluding the lookalike characters takes the pool from 70 down to 66, which costs about 1.4 bits on a 16-character password in exchange for a secret that is easier to transcribe.

For the handful you type from memory: use the passphrase generator, choose seven words where the default six are offered, keep a separator so the boundaries survive, and turn on the number switch only if the site demands one. Read it back once before you leave the page, then close it — the on-screen copy is gone on reload, which is the behaviour you want.

For the accounts that would hurt most: uniqueness first, two-factor second, and a password you have never typed on another site. Everything else in this guide is a way of getting those three properties without memorising hundreds of strings.

• Typed by hand: passphrase, seven words, one separator style you keep using.
• Typed by a manager: 20 or more random characters, unique per site.
• Everywhere: no password used twice, two-factor on mail, bank and the account that resets passwords.

Frequently asked questions