$SIGN #SignDigitalSovereignInfra @SignOfficial
I used to think identity problems were just about data not being shared properly. It felt obvious. If systems could simply access the same information, everything would work better. No repeated onboarding, no delays, no unnecessary friction.
But the more I looked at how identity actually works across countries, the less that explanation made sense to me.
Because the data is already there.
Governments have civil registries. Banks hold KYC records. Agencies track everything from taxes to benefits. In theory, identity is already well documented. And yet, every time you move between systems, you are asked to prove yourself again.
That’s when it started to click for me.
Identity today is not a data problem. It’s a verification problem disguised as a data problem.
Most systems don’t fail at identity. They fail at trusting each other.
You can see this in something as simple as opening a fintech account. The app is legally required to verify your identity, your age and your address. That’s it. But once it connects to a centralized identity system, it often receives far more than that. Full name, full history, linked identifiers. Not because it needs all of it, but because the system makes it available.
Compliance becomes the reason. Data accumulation becomes the outcome.
That’s not a misuse of the system. That’s how the system is designed.
Most countries didn’t build identity systems from scratch. They accumulated them over time. One system for citizens, another for financial compliance, another for public services. Each system works within its own boundary, but the moment they need to interact, things start breaking down.
To solve this, countries usually move in one of three directions.
The first is centralization. One system becomes the main source of truth, and everything connects to it. This makes onboarding easier and standardizes verification, but it creates a new problem. Once everything flows through a single system, that system becomes too powerful. It holds all the data, sees all the activity and slowly turns into a place where more information is shared than actually needed.
The second approach is federation. Instead of merging systems, you connect them through an exchange layer. Each agency keeps control of its own data, but they can communicate through defined rules. This feels more realistic, but it introduces coordination complexity.
A simple example is applying for unemployment benefits. You authenticate once, and the system pulls data from tax records, labor agencies, and civil registries. Each piece makes sense on its own. But the exchange layer sees the full interaction every request, every timestamp. Even if no single agency has full visibility, the system as a whole does.
The third approach is the one that made the most sense to me when I first saw it. Instead of systems pulling data, users present proofs. Credentials are issued once and reused when needed. You don’t send your full identity every time, just the specific proof required.
But even this approach doesn’t work on its own. It needs structure. Someone has to define who can issue credentials, how they are verified, and how they are revoked. Without that, it becomes difficult to trust at scale.
This is where most discussions get stuck. People try to pick one model as the solution. But the more I think about it, the more it feels like the wrong question.
Because none of these models actually solve the core issue on their own.
They just move it.
Centralization concentrates trust. Federation distributes it. Wallets relocate it.
But none of them define it clearly.
That’s where @SignOfficial started making sense to me.
Not as another identity system, but as a layer that sits underneath all of them. Instead of forcing systems to share raw data, it turns identity into verifiable claims. Each claim has a clear meaning, a known issuer, and a way to be checked independently.
Verification stops depending on access to data, and starts depending on the ability to validate a claim.
This changes how systems interact. They don’t need to trust each other blindly anymore. They only need to verify that a claim is valid.
Data doesn’t need to be copied across systems. Users don’t need to repeat the same process again and again. And verification becomes something that can move across systems without breaking.
The more I think about it, identity systems were never really designed to verify each other. They were designed to store.
SIGN doesn’t try to store identity better.
It changes what systems rely on to trust it.