Your Career, Onchain: Building a Resume Protocol with Purpose and Trust

Imagine if your professional skills weren't just claims on a PDF, but verifiable facts backed by the people you've worked with.

In the traditional world, anyone can write "Expert in Solidity" on a resume. But how do you verify it? You have to trust them, or spend hours calling references.

I wanted to solve this by building the Resume Protocol: a decentralized registry for peer-to-peer professional endorsements.

In this article, I want to take you through the journey of building this project. We'll skip the complex jargon and focus on the why and the how. Whether you are a complete beginner to crypto or a developer looking to understand thoughtful smart contract design, you are in the right place.

Let's build something you can trust with clarity, purpose, and excellence.

The Problem: Trust and Verification
In the current job market, trust is fragile.

• Fabrication: Anyone can claim any skill.
• Centralization: Your LinkedIn endorsements live on Microsoft's servers, not in your pocket.
• Permanence: If a platform shuts down, your reputation goes with it.

I wanted to solve this by applying a core philosophy: Reliability. I wanted to build a system where your professional reputation is:

• Verifiable: Endorsements come from real, trackable addresses (peers or trusted oracles).
• Soulbound: The tokens are bound to your wallet. You can't sell your reputation to someone else.
• Consensual: You have control over which endorsements appear on your profile.

The Solution: Soulbound Tokens (SBTs)
You might have heard of NFTs (Non-Fungible Tokens) for digital art. For this project, we use a special kind of NFT called a Soulbound Token (SBT).

Think of an SBT as a university degree or a medal.

• It is unique to you.
• It cannot be sold or transferred to someone else (you can't sell your degree).
• It stays with you forever (or until revoked by the issuer).

In my protocol, when a colleague endorses you for "Smart Contract Engineering," they aren't just sending a message; they are minting a permanent, verifiable token directly to your digital wallet.

Traditional Resume vs. Onchain Protocol

Feature	Traditional Resume	Resume Protocol (Onchain)
Source	Self-claimed	Peer-verified
Ownership	Hosted by platforms	Owned by YOU (Soulbound)
Trust	Hard to verify	Cryptographically verifiable
Transferability	N/A	Non-transferable (Identity-bound)

How It Works (The Architecture)
I believe that excellence lies in clarity. So, let's break down the flow of an endorsement using a simple analogy.

The Analogy: Imagine a Digital Award Ceremony.

• The Issuer (your manager) decides to give you an award.
• The Protocol (the stage) checks if they are allowed to give awards right now (Rate Limiting).
• The Award (the Token) is presented to you.
• The Status: It starts as "Pending" until you walk up and accept it.

1. The Endorsement Flow
This diagram shows how a user interacts with the system to send an endorsement.

2. The Lifecycle of an Endorsement
One of the unique features of this protocol is the "Consent" mechanism. You shouldn't have to display endorsements you don't want. Here is how the state machine works:

Building with Philosophy: The Tech Stack
When I build, I choose tools that align with security and thoughtfulness.

• Base (L2): A resume protocol needs to be accessible. Base offers the security of Ethereum with the low costs required for a social graph.
• Solidity: The language of the contract.
• Foundry: A robust toolkit for testing. I used Foundry to ensure the code is "battle-tested" before deployment.

A Look at the Code
Let's look at the heart of the protocol. This is the function a peer calls to endorse you. Note the specific checks we put in place to ensure reliability.

/**
 * @notice Peer-to-Peer Endorsement with Anti-Spam checks.
 * @dev Enforces Rate Limits. Mints as PENDING (requires acceptance).
 */
function endorsePeer(address to, string calldata skill, string calldata dataURI) external {

    // 1. Reliability Check: Rate Limiting
    // We prevent spam by ensuring a cooldown period between endorsements.
    // If you endorse too fast, the contract protects the system and reverts.
    if (block.timestamp < lastEndorsementTimestamp[msg.sender] + RATE_LIMIT_COOLDOWN) {
        revert RateLimitExceeded();
    }

    // 2. State Management: Mint as Pending
    // Endorsements aren't automatic; they start as 'Pending' to respect the recipient.
    // This uses our internal helper `_mintEndorsement`.
    _mintEndorsement(msg.sender, to, skill, dataURI, Status.Pending);

    // 3. Update State
    // We update the timestamp to enforce the cooldown for the next call.
    lastEndorsementTimestamp[msg.sender] = uint64(block.timestamp);
}

Making it "Soulbound"
To ensure you can't sell your reputation, we override the transfer logic. If you try to send this token to someone else, the contract simply says NO.

function _update(address to, uint256 tokenId, address auth) internal override returns (address) {
    address from = _ownerOf(tokenId);
    // If the token is already owned (from != 0) and trying to move (to != 0)...
    if (from != address(0) && to != address(0)) {
        revert SoulboundNonTransferable();
    }
    return super._update(to, tokenId, auth);
}

Excellence in Engineering: Testing
Writing the code is only half the battle. To truly align with the value of Excellence, the code must be rigorous.

I used Foundry to run extensive tests, including:

• Unit Tests: Checking every function individually.
• Fuzz Testing: Throwing random data at the contract to see if it breaks.
• Invariant Testing: Ensuring core truths (like "Users can never transfer tokens") always hold true.

Result: 100% Function Coverage and passing Fuzz tests across thousands of scenarios.

How to Get Involved
This project is a step toward a future where we have total control over our digital identities.

I believe in building in public. The entire codebase is open-source. You can explore the endorsement logic, the anti-spam mechanisms, and the test suites on GitHub.

Repository: github.com/obinnafranklinduru/nft-resume-protocol

I am Obinna Duru, a Smart Contract Engineer dedicated to building reliable, secure, and efficient onchain systems.

Let's connect and build something meaningful.

• LinkedIn
• Twitter/X
• Portfolio

📚 Beginner's Glossary

• SBT (Soulbound Token): A non-transferable NFT. Once it's in your wallet, it's yours forever (unless revoked).
• Smart Contract: A digital program stored on the blockchain that runs automatically when specific conditions are met.
• Rate Limit: A security feature that prevents users from spamming the network by forcing them to wait between actions.
• Foundry: A blazing fast toolkit for Ethereum application development written in Rust.
• Onchain: Anything that lives directly on the blockchain.

"Smart contracts handle real value, so I build with reliability, thoughtfulness, and excellence."