What a passkey is and why it solves the password problem
A passkey works with a key pair. The private key stays on the user's device and never leaves it. The public key stays on your server. At login, the server sends a challenge, the device signs that challenge after the user authenticates locally, and the server checks the signature.
Notice what doesn't exist in this flow: there is no shared secret stored in your database. If someone steals the database, they get public keys, which are useless for signing in anywhere. There is also nothing for the user to type, so there's nothing to hand over on a fake site.
Under the hood, this relies on open standards (WebAuthn and FIDO2). Browsers and operating systems from the major vendors already support it, and password managers can also store passkeys.
Why this topic is now on the agenda for app owners
The reason is practical. Weak, reused, and leaked passwords remain the most common way into account takeovers, and fake-page scams catch even careful people. Passkeys tackle both problems at once.
The other reason is user experience. People who already use passkeys on big services start to find apps that still ask for a password, an SMS code, and a second step awkward. A shorter login also reduces drop-off at sign-up and during password recovery, which is one of the most repetitive support tickets there is.
What changes in your app or system
On the front end, the change is small: call the browser's or mobile system's credentials API. The heavy part is on the server, and that's where budgets go wrong.
In practice, the team needs to handle these points:
- Credential registration: a user can have several passkeys (phone, laptop, physical key), and your database needs to model that.
- Server-side verification: validate the signature, the challenge, the domain origin, and the usage counter, using a mature library rather than code written from scratch.
- Coexistence with the password: during the transition, both methods live side by side, and the security rules for each must be clear.
- Account recovery: what happens when the user loses their device and has no other one registered.
- Session and permissions: a passkey solves authentication, not authorization. Profiles, roles, and session expiration are still your job.
- Logging and auditing: record when and how each login happened, especially in systems with sensitive data.
Common mistakes when adopting passwordless login
The mistake we see most is treating a passkey as one more button on the login screen. It works in the demo and breaks with the first user who switches phones.
Other frequent missteps:
- Turning off the password too early, before most users have a passkey registered.
- Leaving account recovery weak. If the recovery flow is a simple email, the attacker just ignores the passkey and uses recovery.
- Forgetting shared devices, common at service counters, on factory floors, and in kiosks, where each person needs their own way to identify themselves.
- Not testing real combinations of browser, operating system, and password manager. Behavior varies, and that's where support tickets show up.
- Writing the cryptographic verification by hand. That's an invitation to subtle flaws.
What if the system is legacy?
Here we have a clear position: don't rewrite an entire system just to get a modern login. The safest path is to put an identity layer in front, either a login provider or your own authentication service, that understands passkeys and hands the old system a session it already knows how to read.
This fits with incremental modernization. The system keeps running, authentication is swapped for a new front door, and the old screens and rules stay as they are until there's a reason to touch them. Before starting, it's worth mapping where the old system stores and validates passwords, because sometimes they're scattered across more than one module.
It's also a good moment to unify duplicate logins. Many companies discover that the same employee has three users in three systems.
How much it costs and what it depends on
We can't promise a price without seeing your scenario, but we can tell you what drives it. The cost goes up when the current login is homegrown and spread out, when there are several systems with their own authentication, when there are audit or regulatory requirements, and when your audience uses a wide variety of devices.
It goes down when an identity provider already exists, when the app is new and authentication is still being designed, and when a gradual rollout is acceptable. Using an off-the-shelf provider reduces development, but it brings recurring costs and dependency, and that has to be factored in.
Step by step: adopting without locking anyone out
This is the order we recommend for an app or system in production:
- Map how login works today: passwords, SMS, SSO, profiles, and where each piece is validated.
- Define the account recovery plan before writing a single line of passkey code.
- Choose between your own library or an identity provider, weighing cost, dependency, and your industry's requirements.
- Release passkeys as an option, inviting users to register one after a successful normal login.
- Track adoption and support tickets for a few weeks.
- Only then tighten up the password: require a passkey for sensitive actions and, at the end, make the password optional or remove it.
Frequently asked questions
Is a passkey more secure than a password with two-factor authentication?
Generally, yes, especially against fake pages, because a passkey only responds to the real domain and there's no code that can be relayed. Final security still depends on a good account recovery flow.
What happens if the user loses their phone?
If the passkey is synced through the user's password manager, it comes back when they sign in on the new device. If not, they need another registered passkey or a recovery process defined by your app, which is why that flow must exist before launch.
Do I need to rewrite my old system to use passkeys?
Not necessarily. You can put an authentication layer in front of the legacy system and keep everything else as is, which is cheaper and less risky than rewriting.
Can I eliminate the password all at once?
Technically, yes, but we don't recommend it. Start with passkeys as an option, track adoption, and only remove the password once account recovery has been tested and most users are already using the new method.
Do passkeys work for a company's internal systems?
They do, and that's often where they make the most sense, integrated with employees' single sign-on. You just need to think about shared devices and how to restore access for someone who lost their work device.
Conclusion
If your app or system has a login today, the next step is a small one: ask your team for a map of how authentication works and where password and account recovery tickets come from. With that in hand, you can decide whether it pays to use an off-the-shelf provider or build the verification yourself, and start with passkeys as an option alongside the password. If the system is old and nobody is sure where the login is validated, start there. SKAD does this assessment and the step-by-step adoption without stopping your operation.