In most identity architectures today, everything revolves around connecting systems.
You verify a user. You store their data. Then you build integrations so other systems can access it.
That model has worked for a long time. But it comes with a trade-off: every new system means another integration, another copy of the data, and another place where identity has to be reconstructed.
One idea we explored in our recent masterclass is a simple shift in how to think about this:
What if identity didn’t just live in systems, but could move between them when needed?
Traditionally, identity is treated as rows in a database.
Each system holds its own version of the user. Each system decides what it trusts. And each system requires its own onboarding or verification step.
That’s why you end up with the same person existing multiple times across your environment, often with slightly different data and different levels of assurance.
The alternative is to treat identity as something portable.
Instead of storing identity data only inside siloed systems, you package verified data into reusable credentials.
These credentials are issued once by a trusted source and can then be presented wherever they’re needed.
In the masterclass, we described this as moving from connecting systems to creating a “web of data”, where trusted identity information can flow between sources and its consumers.
This changes how identity works in practice.
Instead of tightly integrating every system with every other system, you allow applications to request and verify trusted data directly from the user’s ID wallet.
When a user interacts with a service, they can share the specific information needed for that interaction, with their consent.
In other words, the data can move with the user, with their consent, when it’s needed.
This shift unlocks something important: flexibility.
New applications don’t need deep integration with your entire identity stack, they just need to be able to verify digital ID credentials.
New data sources can be introduced without restructuring existing systems, simply by issuing new digital IDs.
And instead of trying to keep every system in sync, you can reduce duplication by reusing already verified data.
It’s a different way of thinking about identity.
Less about building tighter connections between systems. More about making trusted data portable and reusable.
And importantly, it doesn’t require replacing everything you already have.
