The Journey of an SSI Developer
**“A Journey of a Thousand Miles Begins with One Step” — Lao Tzu, a renowned Chinese philosopher.**italic text
Every long journey begins with the first step, and we at Affinidi, welcome you to take this first step in the journey towards becoming an accomplished Self-Sovereign identity (SSI) developer.
While every individual’s journey is unique, we have put together a series of steps that can make your journey fulfilling.
Learn the Concepts and Benefits of SSI
The first step is to understand the concepts of SSI and Verifiable Credentials (VCs), so you can know their benefits, where they can be most effective, and how they can impact the future of digital identity.
Browse through our 101 articles and FAQs to get a good grasp of the concepts.
Once you understand the concepts, you can identify the business use-cases that are most conducive for VCs and work on developing them.
The good news is VCs can be used for developing a wide range of use-cases. In fact, any application that requires a digital identity and authentication is a good fit for SSI. Here are some PoCs that our Hackathon participants developed using our tech stack.
Compute the Cost of Development
The next step is to estimate the overall cost of development.
To do this, you must come up with a high-level technical architecture of your solution, so you can determine the resources you’ll need for its development, and also estimate the duration by which it will be ready. Based on these estimates, determine the overall cost of development.
Armed with the technical architecture and budget, you can convince the stakeholders to buy into your use case.
Expand your Architecture Diagram
Once you have the buy-in, it’s time to work towards developing a pilot solution.
Start with your architecture and build on it. Break it down into small modules and create architecture diagrams for each module.
Also, design the business flow for your system, so there’s high-level visibility into your system’s architecture and functionality.
Build a VC Schema
Next, come up with the different types of VC schemas your application would need.
Browse through our VC-Generator app to get an idea of what schemas you’ll need for your application and make a list accordingly.
Once you have the list, it’s time to build the different VC schemas using our Schema Manager. You can use the Schema Manager to build new schemas or to reuse the existing ones.
Seed Verifiable Data
With the schemas in place, it’s time to start seeding the schemas with verifiable data. You can seed the digital identity of the issuers and verifiers to anchor them and give control of their respective Decentralised Identifiers (DIDs). Next, generate the metadata of both the parties of the trust triangle and establish the public key of the issuer.
Build the Issuance Tool
Now, it’s time to build the issuance tool based on the type of issuances in your proposed application. The type of issuance will depend to a large extent on whether you are building a generic portal, an on-prem app, API, or a plugin for an existing tool.
Build or Integrate the Edge Agent and Storage
Your next step is to build or integrate both the edge agent and the storage.
The edge agent can be a white-label web or mobile wallet that your end customer already uses. For new users, consider/recommend Affinidi’s web and mobile wallet as it can be easily integrated with the rest of your application. You can use the Affinidi vault for storage.
Create the Verification Tool
With the credentials ready, you need a way to verify them. For this, build a verification tool using a generic portal, a gateway API, or an SDK, as required.
Build the UI for Presentation and Exchange
Next, create a visually appealing and intuitive UI for information exchange.
If you’re using an API for verification, you may want to create an API for this presentation exchange.
In both cases, you may want to create a protocol for verifiers to request a verifiable presentation or a partial VC (in the case of selective disclosure) from the holder.
Create the Issuer/Verifier Registry
Finally, build a verifier or issuer registry along with tools to edit them.
As a part of this tool, you must generate an entity VC, which is a VC that authorizes an issuer to issue certain types of VCs. You can also work on publishing the metadata in this stage. With this, you have built a pilot solution for your SSI application.
Do a Test Run
It’s now time to do a test run of your application. Make sure your application issues VCs and stores them in the holder’s wallet. It should also enable the holder to create a verifiable presentation and share it with a verifier when needed.
Collect and analyze the report of your test runs and present them to the stakeholders involved.
Based on the reports and test runs, make the necessary changes to your application to ensure that it meets your business goals. Test the application iteratively to ensure that it works the way you want.
Deploy in Production
After making the necessary changes, deploy it in production. Add VC revocation capabilities if you have not done it already.
Maintain and Scale
Lastly, stay on top of the usage analytics and create a commercial model that will generate revenue for you.
Continuously monitor user behavior and make the necessary updates to your product. Once you have scaled the application, think about opening the ecosystem and creating a marketplace around it.
Thus, this is the journey of an SSI developer using Affinidi’s tech stack.
Example Use Case
To understand this journey, let’s take our driving license example.
To build an app that issues, stores, and verifies the driving license verifiable credential, you must,
- Know the concepts of VCs and the advantages of building a VC-based application.
- Identify a use-case. For example, you can integrate this driver’s license VC with an auto insurance app to determine the yearly premium of the holder.
- Calculate the cost of development including the time and resources required.
- Create an architecture diagram of the implementation and include its integration with the wider use-case, which in this example, can be the premium computation app.
This article contains the technical implementation using Affinidi’s tech stack.
Next, build the UI for presentation, create a registry, and do a test run.
Based on the test results, make changes if needed, and deploy it in production.
We hope this use-case gives you an idea of the developer journey and where you are in it, and we look forward to seeing your SSI apps built using our tech stack.
Please reach out to us on Discord if you have any questions, join our mailing list, and follow us on LinkedIn, Twitter, and Facebook.
The information materials contained in this article are for general information and educational purposes only. It is not intended to constitute legal or other professional advice.