Passwords have been the default way to sign in to web apps for decades, and they have been the source of a long list of problems: reused credentials, phishing, password-reset tickets and frustrated users who abandon sign-up halfway through. Passkeys offer a real alternative, and with support now built into the major browsers, operating systems and password managers, they have become something users increasingly expect rather than a novelty.
This guide explains what passkeys are, how they fit into an existing authentication system, and how to roll them out in phases so you raise security without hurting sign-in conversion.
What a Passkey Actually Is
A passkey is a credential based on the WebAuthn and FIDO2 standards. Instead of a shared secret (a password) that both the user and the server know, a passkey uses a public–private key pair:
- The private key stays on the user's device or in their platform password manager (for example, iCloud Keychain, Google Password Manager or a third-party manager). It never leaves that secure storage.
- The public key is stored by your server.
- To sign in, your server sends a challenge, the user's device signs it with the private key after a local check (fingerprint, face, device PIN), and your server verifies the signature with the public key.
Because the passkey is bound to your domain, a look-alike phishing site cannot use it. And because your database only holds public keys, a breach doesn't hand attackers anything they can replay elsewhere.
Synced vs. device-bound passkeys
Most consumer passkeys today are synced: they are backed up through the user's platform account and available across their devices. Some enterprise scenarios call for device-bound passkeys, such as those on hardware security keys, which never leave a single device. For most web apps, supporting synced passkeys first gives the best balance of security and convenience.
Why Now Is a Good Time to Add Passkeys
Several things have changed that make passkeys practical for everyday web products:
- Broad platform support. Modern browsers and mobile operating systems support passkey creation and sign-in natively.
- Cross-device sign-in. Users can sign in on a laptop using a passkey stored on their phone, usually by scanning a QR code.
- Autofill integration. Conditional UI lets the browser suggest a passkey directly in the username field, so signing in feels as simple as tapping a suggestion.
- Mature libraries. Well-maintained server and client libraries exist for most popular stacks, so you don't need to implement the cryptography yourself.
The result is that adding passkeys is now mostly a product and UX challenge, not a research project.
How Passkeys Fit Into Your Existing Login
You don't need to rebuild authentication from scratch. The most common approach is to treat a passkey as an additional credential type attached to an existing user account.
The data you'll store
For each passkey, your backend typically stores:
- A credential ID
- The public key
- The user it belongs to
- A signature counter and flags (such as whether it is backed up)
- Friendly metadata, like the device or manager name and when it was created and last used
Allow multiple passkeys per user. People switch phones, use several password managers, or want a hardware key as a backup.
The two core flows
- Registration: a signed-in user (or a new user at sign-up) asks to create a passkey. Your server generates options and a challenge, the browser creates the credential, and your server verifies and stores it.
- Authentication: your server issues a challenge, the browser asks the user to choose a passkey and verify locally, and your server validates the signed response and starts a session.
Use a reputable WebAuthn library for both flows, and make sure challenges are single-use and short-lived.
A Phased Rollout Plan
Rushing to "passwordless only" is the most common way to cause support headaches. A phased plan works better.
Phase 1: Offer passkeys as an option
- Add a "Create a passkey" option in account or security settings.
- Prompt users to create one at a moment of high intent, such as right after a successful password sign-in or after completing a sensitive action. Keep the prompt short and skippable.
- Explain the benefit in plain language: faster sign-in, no password to remember, harder to phish.
Phase 2: Make passkeys the easy path
- Enable conditional UI so the browser offers saved passkeys in the username field automatically.
- Show "Sign in with a passkey" prominently on the login page, rather than burying it under the password field.
- During sign-up, offer passkey creation as the default, with a password or email link as an alternative.
Phase 3: Reduce reliance on passwords
- For users who have created a passkey and used it successfully, stop asking for their password on routine sign-ins.
- Consider letting users remove their password entirely once they have at least one working passkey plus a recovery method.
- Decide on a timeline for sunsetting password-only sign-up based on your own adoption data, not a fixed date.
Don't Forget Account Recovery
A passkey rollout is only as secure as its weakest fallback. If anyone can bypass a passkey by clicking "Forgot password" and receiving a reset link, attackers will target that route instead.
Practical recovery options include:
- Multiple passkeys — encourage users to register a second one on another device or manager.
- Verified email or phone recovery with rate limiting and notifications to the account owner.
- Step-up checks for high-value accounts, such as identity verification or a cooling-off period before recovery completes.
- Clear notifications whenever a passkey is added or removed, so users can spot unexpected changes.
Write down the recovery policy before launch and test it with real support scenarios.
UX Details That Make or Break Adoption
Small design choices have an outsized effect on whether users actually use passkeys:
- Use consistent naming. Call them "passkeys" everywhere; it is the term platforms use and users are learning.
- Show a credentials list. Let users see, rename and remove their passkeys, with created and last-used dates.
- Handle errors gracefully. If a user cancels the system prompt, return them to the login page with a clear alternative, not a cryptic error.
- Test across environments. Check desktop and mobile browsers, cross-device QR sign-in and at least a couple of password managers.
Measuring Success
Track a few simple metrics from day one:
- How many active users have created at least one passkey
- What share of sign-ins actually use a passkey
- Sign-in success and abandonment rates by method
- Password-reset and account-recovery ticket volume
Enrollment and usage are different things. A user who created a passkey but still types a password every time tells you the login page needs work.
Security and Compliance Notes
- Validate the origin and relying party ID on every response.
- Keep your WebAuthn library up to date.
- Log credential events for auditing.
- If you operate in regulated sectors, check how passkeys map to your strong customer authentication or multi-factor requirements, and document the decision.
Conclusion
Passkeys are one of the rare security improvements that also make life easier for users. The teams that succeed treat the rollout as a product change: introduce passkeys gently, make them the most convenient path, protect the recovery flow and measure real usage before retiring passwords.
If you're planning to add passkeys to an existing web or mobile product, or modernize authentication more broadly, the Codonnier team can help you design the flows, integrate WebAuthn into your stack and roll it out safely. Get in touch to talk through your login roadmap.