“Digital identity” is the sum of the digital proofs that make people recognisable and verifiable online. This includes simple things such as a login, email address and profile, as well as robust indications of what someone can do or has done.
This text is aimed at developers and recruiters who are not yet familiar with W3C Verifiable Credentials. It explains the term without jargon: what digital identity means in hiring, why verifiable proofs are becoming more important, and how this works in practice.
For context, you can find more for developers with a free repo audit, for companies during verification, on the Proof Engine methodology and on pricing without a subscription.
What digital identity really means
Digital identity is an umbrella term. It means everything that connects a person to the internet: information, characteristics, traces and proofs. Some of these are very simple, such as a user account, an email address or a login. Others are more professionally relevant, for example a public profile, a portfolio or a certificate.
The key distinction is between a claim and a proof. A profile, CV or short description initially only says: "This is who I am" or "This is what I can do". That can be useful, but it remains a self-declaration. A verifiable proof goes further: it demonstrates something in a way that others can check and assess more reliably.
This is crucial in recruitment in particular. What matters there is not only who someone is, but also which qualifications, experience or performance can be credibly evidenced. For developers, this can be especially relevant because practical work often says more than general buzzwords. For recruiters, what matters is whether the visible impression is also robust.
Today, digital identity often appears fragmented. One part sits in an email account, another in platform profiles, and more still in PDFs, portfolios or certificates. This creates a picture made up of many individual pieces of data, but not automatically a coherent, verifiable whole.
That is the core problem: a great deal is visible, but not everything is equally trustworthy or rich in context. This is exactly where verifiable proofs become the next stage of digital identity.
Why digital identity in tech hiring is more than a profile
In tech hiring, professional substance often shows up first not in buzzwords but in real artefacts. These include code, commits, tests, dependencies and technical decisions. That is exactly where it becomes visible how someone works, how carefully changes are made, and what traces their own work leaves in the development process.
A CV or profile still remains useful. Both bring together roles, technologies, projects and career stages in a compact form. The problem is simply this: such documents mainly collect claims. They say what someone says they worked on, but not automatically how robust that claim is in the specific context. Only through assessment or verification does it become proof that can be judged more reliably.
This is particularly relevant for recruiters because technical quality is difficult to assess from the outside. If what is available is mainly documents, self-presentation or short tasks, a lot remains unclear:
- How much genuinely comes from the person themselves?
- How was work done in the project?
- Are there signs of care, maintainability or risk?
For developers, the question is different: how can you evidence your own work without passing raw data around indiscriminately to many places? This too is part of digital identity in professional life. It is not only about being visible, but about making proofs usable in a controlled and traceable way.
In this context, people talk about evidence-based hiring. What this means is an approach in which decisions rely more on evidenced work than on mere claims. Acquispect is one example of this: instead of auditing a CV, it audits a developer’s Git repository.
How verifiable proofs work: W3C Verifiable Credentials
W3C Verifiable Credentials, often shortened to VCs, are standardised digital proofs. Put simply: they are proofs that can not only be displayed but also checked cryptographically. This makes it possible to verify whether a proof is genuine and whether it has remained unchanged since it was issued.
For beginners, the most important difference from a PDF or screenshot is easy to explain. A PDF may look convincing, but it is initially only a document. A screenshot likewise only shows a view. A Verifiable Credential goes further: it carries technical properties that allow its authenticity to be checked. So visibility alone is not enough; verifiability is added.
In the web context, did:web plays a role here. Put simply, it is a method of binding a verifiable digital identity to a web address. You do not need to know the technical details for this. The only thing that matters is this: there is a standardised way to anchor the origin of a proof in a traceable manner.
It is also important where the proof is stored. A VC does not have to be stored only in someone else’s system. It can sit in the person’s own wallet — here, the developer’s. The wallet is therefore the place where your own proof is held and presented when needed.
This fits the principle of selective verification:
- the proof is verified,
- not automatically all of the underlying material,
- and not every piece of raw information has to be openly passed on.
The practical benefit is clear on both sides. Developers retain more control over their proof. Companies receive a verifiable status rather than mere self-declarations. Verifiable Credentials are not limited to developers, but in this context they are particularly well suited to making evidence of work digitally portable.
A concrete example: digital identity from real development work
How does development work become a verifiable part of digital identity? One concrete example is the process at Acquispect. There, the Proof Engine does not audit the CV, but real work in a Git repository — in three stages.
Stage A: Ghostwriter Detector
First, the .git history is analysed forensically. This focuses, among other things, on three questions:
- Who actually authored the commits?
- Are there indications that code was dumped into the repository in larger blocks?
- What impact do the contributions show over time?
The result is not merely a gut feeling, but a structured analysis of the development traces.
Stage B: Safety Check This is followed by a technical security and quality review of the repository. The checks cover:
- leaked secrets,
- known vulnerabilities in dependencies,
- test coverage,
- the tech stack.
This means the work is not viewed only as activity, but also in terms of risk and technical classification.
Stage C: AI Expert Panel After that, a panel of five AI expert personas assesses the results: Tech Lead, Security, Performance, Architect and Craftsman. These five perspectives arrive at a consensus verdict. Importantly, the verdict is not presented as absolute certainty, but explicitly with a confidence score.
At the end, this verdict is sealed as a W3C Verifiable Credential via did:web and placed in the developer’s wallet. The proof therefore sits with the developer themselves.
When a company later verifies it, it sees the verdict rather than the raw data. In addition, it can read the full audit log in order to understand how the assessment was reached.
Anyone who wants to understand the individual verification steps in detail can find them in the methodology.
What this changes in practice for developers and companies
For developers, the focus of digital identity shifts noticeably. Instead of mainly having to explain yourself through profile text, buzzwords or self-presentation, your professional proof can rest more strongly on evidenced work. This is especially relevant where real development traces say more than a short description in a CV.
There is another point too: the proof belongs to the developer themselves. The credential sits in your own wallet, not only in someone else’s system. As a result, digital identity is not merely visible, but also remains in the hands of the person it relates to.
For companies, what changes above all is the nature of verification. What is verified when needed is a verifiable result, not a disorganised pile of raw information. That makes the assessment clearer:
- the visible part is the verdict,
- supplemented by the audit log,
- without automatically disclosing all raw repository data.
The role model is also clearly separated: developers are audited free of charge. Companies pay per verification, with no subscription. If the use case needs to go further, an enterprise offering is available on request.
Frequently asked questions about digital identity
What is the difference between digital identity and an online profile?
An online profile is only one part of digital identity. It shows how a person presents themselves: for example roles, career stages, skills or projects. Digital identity is broader. It also includes logins, accounts, visible traces on the internet and, above all, proofs that can be verified.
Put briefly:
- A profile describes.
- A digital identity combines description and proofs.
- Verifiable proofs make claims more robust.
What is a W3C Verifiable Credential in simple terms?
A W3C Verifiable Credential is a digital proof whose authenticity and unchanged state can be verified. So it is more than a document to look at. In hiring, this means that what is passed on is not just a claim, but a verifiable proof about a result.
At Acquispect, the verdict of a repo audit is sealed as such a credential via did:web and stored in the developer’s wallet.
Why does a company not simply see all the raw data from the repository during verification?
Because verification here works selectively. The company is meant to see the verifiable result, not automatically the entire raw body of development work. This keeps verification focused on the relevant verdict. Anyone who needs more context can also read the full audit log.
Who owns the credential after the audit: the developer or the platform?
The developer. The credential sits in the developer’s own wallet. So it is not only a platform that holds the proof, but the person it refers to. Companies verify it when needed.
Is the result of such an audit a certain truth or an assessment with uncertainty?
It is not a certain truth in the absolute sense. At Acquispect, the result comes from three stages: forensic .git analysis, Safety Check, and a panel of five AI expert personas. This produces a consensus verdict with a confidence score. In other words: a reasoned, verifiable assessment with stated uncertainty.
Conclusion: digital identity becomes valuable when it is evidenced
Digital identity is more than an account or profile. It becomes genuinely useful when claims turn into verifiable proofs.
For developers and recruiters, W3C Verifiable Credentials provide a clear framework for this:
- proofs become verifiable,
- the context remains assessable,
- and the developer keeps the proof with them.
When real development work is audited and stored as a verifiable credential in the developer’s wallet, digital identity becomes more tangible, more portable and easier to assess in hiring situations.