Self-sovereign identity vs federated login

Most people's working digital identity today is a federated login: an account with a large platform, reused to sign in everywhere else. Federation solved a real problem — hundreds of passwords — and it solved it well. But it solved it by making one company the operator of your identity, and that arrangement has consequences that only become visible when something goes wrong.

The alternative gathering momentum across standards bodies and open-source projects is self-sovereign identity (SSI): an architecture in which you hold your own credentials in a wallet you control, and prove things to services directly, without an identity provider sitting in the middle of every interaction. The Identity Wallet is an implementation of this idea. Comparing the two models honestly — including SSI's real costs — is the best way to understand why the shift matters.

When you "sign in with" a platform, three things happen. The platform authenticates you against its records; it tells the service who you are (as an identifier it controls); and it logs the interaction. Multiply by everything you sign into and the platform holds a continuously updated map of your digital life — every service, every session — as a by-product of authentication.

The failure modes follow from the structure. Your account is suspended, mistakenly or otherwise — every dependent login dies with it, with appeal processes designed for scale rather than justice. The provider is breached or compelled — the map of your logins is exposed in one place. The provider changes terms, pricing or existence — every dependent service and user absorbs the change. None of this requires bad faith; it is what happens when identity is an asset on someone else's balance sheet.

In the wallet's implementation, the anchor is the VirtEngine network rather than a company: verification results and consent records are held on a chain no single party administers, evidence stays encrypted under your keys, and the credentials you present reveal only what each interaction needs. The honeypot analysis explains why removing the central operator is a security feature, not just a governance preference.

• Custody: credentials live in your wallet — on your device, encrypted — not in a provider's account store. There is no account to suspend.
• Disclosure: you present a credential or a zero-knowledge proof directly to the service. No third party learns where you signed in, because no third party is in the loop.
• Verification: services check cryptographic signatures against a decentralised registry, not by calling a provider's API. Trust flows from mathematics and auditable code, not from a company's uptime.
• Revocation and consent: every sharing decision is explicit, purposed, and revocable in your consent record — not buried in a platform's privacy dashboard.

SSI moves responsibility to the edges, and that is not free. Key management becomes your problem: a wallet is only as recoverable as its design allows, which is why device loss and recovery deserve first-class treatment rather than fine print. Adoption is a network problem: a credential is useful where it is accepted, and acceptance builds service by service. And the user experience must reach parity with "click the button" federation, or convenience will keep winning — as it always does.

It is also fair to say the ecosystem is young. This service describes its own maturity plainly — the wallet is open-source reference infrastructure, not a finished consumer product with app-store listings — because an identity system that oversells itself has already failed at its one job.

The practical future is plural: federated login will persist where its convenience outweighs its risks, and wallet-based credentials will take over where the stakes are high — age, identity, financial standing, professional qualification. The important thing is that the high-stakes path exists at all: that when a service needs to know something real about you, there is a way to prove it that does not create an account someone else controls or an archive someone else can lose. Building that path, openly and verifiably, is what this service is for.