I remember a moment that felt small at the time but stayed with me.
I had to verify myself on two different platforms on the same day. Same documents, same identity, nothing changed. Still, I had to upload everything again, wait again, and go through the same process twice.
At first, I didn’t think much of it. It just felt like how things work.
But later, it started to bother me.
If both systems needed the same information, and that information already existed somewhere, why couldn’t it carry forward? Why did identity feel like something that resets every time you move?
Then it hit me.
It wasn’t because the system didn’t know me. It was because the systems didn’t trust each other.
Once you see that, you start noticing it everywhere.
You verify yourself at a bank. Then again at a crypto exchange. Then again when applying for a loan. Each system asks for the same thing, but none of them accept what the other has already verified.
Not because the data is wrong. Because the trust is not transferable.
To fix this, some countries try to centralize everything. One system becomes the main identity layer. It works well in the beginning because it simplifies integration. But over time, it creates a different kind of problem.
A fintech app that only needs to confirm your age and identity can suddenly access much more. Full profiles become available simply because they exist. The system doesn’t enforce minimal proof. It enables maximum access.
Other countries take a federated approach. They connect systems instead of merging them. This reduces duplication, but it introduces coordination challenges.
Think about logging into a government portal to apply for benefits. You authenticate once, and behind the scenes, multiple systems interact. Tax records, employment data, eligibility checks. Each system contributes a piece. But none of them independently verifies the whole. The process depends on coordination, not verification.
Then there’s a different way of thinking about it.
Instead of systems requesting your data, you present proof of what they need to know. You don’t share everything, only what is required.
That idea felt simple. But the more I thought about it, the more I realized it changes the question entirely.
Systems stop asking “who are you?” and start asking “can this claim be verified?”
That’s a completely different model.
But even this needs structure. Without clear rules around who can issue proofs and how they are verified, it becomes difficult to scale.
That’s when SIGN started to make sense to me in a more practical way.
It doesn’t try to replace existing systems. It doesn’t assume everything should be centralized or fully decentralized. Instead, it focuses on how trust moves between systems.
Identity becomes a set of claims. Each claim is issued by a known authority and can be verified independently. So when a system needs to check something, it doesn’t request your entire profile. It verifies a specific claim.
Verification no longer depends on who holds the data. It depends on whether the claim can be validated.
That changes the experience completely.
You’re no longer repeating yourself every time you move between systems. You’re presenting something that has already been verified, and the system can check it instantly.
The difference feels small at first, but it’s not.
It means identity stops being something that is constantly collected and stored, and starts becoming something that can be proven when needed.
Looking back, that moment of repeating verification wasn’t just friction.
It was a design flaw showing itself.
And once you see it, you stop asking for better UX and start questioning the system itself.
