DEV Community: Vincent Jande

How Web3 Tokens Get Their Value

Vincent Jande — Thu, 07 May 2026 18:03:23 +0000

Someone in the 100 Days of Solana community asked a question last week that needs to be addressed: "What gives SOL its value?"

You have been using SOL in every challenge. You airdropped it, checked your balance, and you are about to start sending it in Arc 3. But where does the value actually come from? Is it just numbers on a screen?

I understand why people think that. Let’s break it down.

Liquidity: Where price comes from

The first thing to understand is that for a token to have purchasing power, there needs to be liquidity. This means there are people or pools willing to trade real assets, such as fiat or stablecoins, for that token. That liquidity is what allows a market price to exist.

Think of it like converting currencies at an airport. You hand over dollars, and you get euros. The value isn't created in that moment; it is a transfer of value from one form to another. In Web3, liquidity is the bridge that connects digital assets to the broader economy.

Different tokens, different sources of value

Not all tokens work the same way. Understanding the types helps you see where the value sits.

Native Tokens: SOL is required to pay transaction fees, stake with validators, and interact with applications. As usage of the network grows, the demand for these specific functions can increase the demand for SOL.
Stablecoins: These are often pegged to a currency like the US dollar. They maintain this peg through reserves and market mechanics. Issuers like Circle hold cash and bonds so you can redeem USDC for dollars.
Utility Tokens: These provide access to specific services, such as in-game items or decentralized file hosting. The token has value because the service it unlocks is useful to someone.
Governance Tokens: These provide voting power. Holding governance tokens for a protocol allows participation in decisions about fees, features, or treasury management.
Meme Tokens: These often derive value from community and attention. While they may begin as jokes, they can build large social networks.

The Solana-Specific Engine

Beyond general categories, Solana has unique technical mechanics that influence its economy:

The Cost of State (Rent) On Solana, storage is not free. Every time you create an account or deploy a program, you must deposit a minimum amount of SOL to make that account Rent Exempt. This SOL is held in the account to keep it active. While it isn't permanently removed, it is temporarily locked, which can reduce circulating liquidity as the ecosystem grows.
The Burn Mechanism Solana has a built-in "fee burn" where 50% of every base transaction fee is permanently destroyed. However, Solana also has inflation (new SOL issued to validators to secure the network). The net effect on supply depends on how much network activity (burn) occurs versus the rate of new issuance.
Efficiency via Proof of History (PoH) Solana’s design enables fast, low-cost transactions (settling in roughly 400ms). This can make certain applications, like high frequency DeFi or real time payments, more efficient. This efficiency increases the usefulness of the network, which in turn supports the value of its native token.

Liquidity pools: How tokens stay tradeable

In Web3, we often use liquidity pools instead of traditional order books. A liquidity pool is a smart contract holding two tokens, such as SOL and USDC. Prices are set automatically using mathematical formulas rather than matching individual buyers and sellers like a traditional exchange.

People who deposit tokens into these pools are called liquidity providers. They put in a balanced value of both tokens and earn a portion of the trading fees. This is how decentralized exchanges like Raydium or Orca function. When more people buy SOL from the pool, it becomes scarcer in that pool, and the price rises automatically.

Is it real?

Value in Web3 comes from the same place all value comes from: utility and demand.

SOL is useful because the network processes thousands of transactions per second for very low costs. USDC is useful because it allows for digital dollar movement globally. DeFi protocols are useful because they provide financial tools without traditional intermediaries.

The infrastructure is different from traditional finance, but the principles are the same. Value frequently follows utility.

What this means for you

You have been working with DevNet SOL, which has no monetary value. However, the mechanics are identical to Mainnet. The RPC calls, the wallet interactions, and the transaction flows are all the same.

In Arc 3, you start sending transactions and moving "simulated value." Understanding how that value flows, even on a test network, makes you a better builder. You are practicing the exact same movements you will eventually perform on Mainnet. Whether you end up creating a payment system, a DeFi protocol, or something entirely new, this technical foundation is where it starts.

Keep building. See you on Discord.

100 Days of Solana is a free daily coding challenge. If you have not joined yet, start here: https://mlh.link/solana-100

Why Web3 Exists and Why Solana Matters

Vincent Jande — Tue, 28 Apr 2026 18:19:40 +0000

You trust middlemen every single day. You probably don't even think about it.

Your bank holds your money. Instagram holds your followers. Spotify holds your playlists. Google holds your emails. Every service you use, someone else is in control. They control access to your data and assets within their systems and policies.

In our current digital landscape, our "ownership" is essentially a managed service. Whether it's a financial institution or a social media platform, your access depends on the stability and policies of the provider. Web3 is the movement to change this, to build an internet where you actually own your digital assets and data.

To make this vision a reality, we need a foundation that doesn't rely on a central boss. This is precisely what blockchain was designed to provide.

So what is a blockchain?

Imagine a notebook that thousands of people have a copy of. Every time someone writes something in it, every copy is updated simultaneously, provided the network agrees the entry meets specific conditions. You can't rip out a page, change what was already written, or claim ownership over the whole thing.

That's the core idea of a blockchain. It is a shared record that functions without a central boss. Once information is recorded, it remains there permanently because the system is designed to prevent anyone from tampering with the history. Instead of trusting a single company to keep the records straight, the system relies on math and a network of computers reaching a consensus.

While this describes the initial "open and ownerless" concept, the technology has evolved to allow for managed variations like private, hybrid, or consortium blockchains, where specific entities or pre-selected groups control the records rather than the general public.

Why does this matter?

It shifts how we handle control and trust in our daily lives.

Moving value without traditional hurdles. Usually, sending money abroad involves a chain of banks. It can take days, involves various fees, and a single institution can decide to halt the transaction. Blockchain allows for more direct transfers that often settle much faster, bypassing many of the usual middlemen.

Agreements governed by code. Think about hiring a freelancer. Rather than relying solely on a handshake or expensive legal backing, you could use a smart contract. The agreement is programmed: when the work is verified, the payment is released automatically. This reduces the need to chase invoices or worry about payment delays.

Secure records of ownership. Most important documents, like house deeds, are stored in centralized offices. If those records are lost, damaged, or altered by error, proving what you own becomes a nightmare. Recording ownership on a blockchain provides a decentralized backup, meaning there is no single point of failure that can wipe out your proof of property.

These aren't just ideas for the future; the infrastructure to support these shifts is being built and used right now.

If it's so great, why hasn't it taken over?

To be honest, the early versions were often slow and expensive.

Bitcoin, the first major implementation, can handle roughly 7 transactions per second. Compare that to Visa, which processes around 65,000. While Bitcoin was a massive breakthrough in proving the concept of decentralized trust, it wasn't originally designed for high-speed, high-volume traffic.

Ethereum expanded the horizon by making the technology programmable. It allowed people to build applications and write smart contracts, but it faced similar growing pains. During busy periods, the network can get congested, causing transaction fees to spike sometimes to $50 or more. High costs like that make it difficult to use for everyday things like buying coffee or paying a small invoice.

For a while, these limitations meant the tech was mostly used for speculation. People traded tokens back and forth, not necessarily because the technology lacked potential, but because the underlying infrastructure was still catching up to the demand.

Where Solana comes in

Solana was built to address these specific bottlenecks.

While many earlier blockchains struggled with low throughput, Solana was engineered to handle thousands of transactions per second. This shift makes the technology much more practical for daily use. Instead of paying dollars in fees and waiting minutes for a confirmation, transactions on Solana typically cost fractions of a cent and finalize in under a second.

This performance is what allows for real-world applications beyond just trading. It opens the door for:

Global payment systems that rival traditional speeds.
Social platforms and games where every interaction doesn't require a massive fee.
Supply chain tracking that needs to record thousands of data points in real-time.

Solana isn't the only high-speed network available, but it has become one of the most battle-tested. With a large developer ecosystem and a growing list of products running in production, it represents a move away from theoretical potential toward actual, scalable utility.

Why you should care right now

If you are a developer, blockchain isn't a "future" skill you can indefinitely postpone. Companies are hiring for it, products are shipping on it, and those who understand the architecture now have a distinct advantage.

The best part? If you know JavaScript, you already have a solid foundation. Building on Solana doesn't mean starting from scratch or throwing away your existing knowledge. Many of the core concepts map directly to the logic and systems you already understand.

Start building

100 Days of Solana is a free, daily coding challenge designed to take you from zero blockchain experience to building functional applications.

The Format: One challenge per day.
The Goal: No prerequisites, just show up and build.
The Progress: Last week, participants set up their first wallets, funding them with test SOL, and interacting with the network. This week, participants will learn how to read the blockchain. By the end of the 100 days, you won't just have theoretical knowledge; you'll have a portfolio of real projects that demonstrate exactly what you can do.

Join 100 Days of Solana

How AI Can Make You a 10x Software Engineer

Vincent Jande — Thu, 14 Aug 2025 20:46:35 +0000

In the rapidly evolving world of technology, artificial intelligence (AI) has sparked intense debates. Some predict that AI will replace software engineers entirely, while others argue that building products has become so straightforward that traditional software engineering skills are obsolete. I strongly disagree with both views. In fact, learning software engineering is more valuable than ever. With a solid foundation, you can leverage AI to handle edge cases, make informed decisions, and automate boilerplate code. This turns you into a productivity powerhouse. In this article, I'll share how I used AI to build a complex product in just three weeks (part-time), what I learned from the experience, and why skilled engineers are uniquely positioned to thrive in this AI-driven era.

The Power of Experience in an AI World

Before diving into the specifics, consider this: I'm currently working on another project where I reached a minimum viable product (MVP) in just a couple of days. Why so fast? My years of software engineering experience allowed me to architect the solution efficiently, anticipate pitfalls, and integrate AI tools seamlessly. Without that knowledge, AI alone wouldn't have sufficed. It's the synergy between human expertise and AI that creates magic.

This brings me to the main story: I was tasked with building a trading academy API. This wasn't a simple app; it needed a full learning management system (LMS) for courses, channels for trading signals, direct messaging (DMs) for user interactions, and subscription management. A project of this scope would typically take several months for a solo developer. But by combining my engineering skills with AI assistance, I completed it in three weeks. And it was not even full-time. If I'd dedicated myself entirely, it could have been done in two. Here's how I did it.

Laying the Foundation: Structure and Tech Choices

Success started with thoughtful planning, drawing on my software engineering background. I knew the pros and cons of common architectures; for instance, the Model-View-Controller (MVC) pattern can lead to cluttered code in larger projects. Instead, I opted for a feature-based structure to keep things modular and scalable.

I chose Node.js with Express.js for the backend to enable rapid development, paired with MongoDB for flexible data storage. Crucially, I designed the features to be loosely coupled, allowing me to build and test one at a time without ripple effects. This modularity is a hallmark of good engineering and made AI integration smoother.

For each feature, I enforced a consistent structure: controllers for handling requests, services for business logic, validators for input checks, routes for API endpoints, models for data schemas, types for TypeScript definitions, and middlewares for cross-cutting concerns. I also created a shared utilities folder for reusable components.

Building Features with AI: From Auth to Messaging

I kicked off with authentication, a standard but critical component. Using Claude (an AI coding assistant), I generated boilerplate code for email-based auth with refresh tokens. The output was well-structured, but it had a few errors, like outdated dependencies, which I quickly fixed using my knowledge. After testing in Postman, it was solid.

Next came user management. I separated the User model (focused on authentication) from the Profile model (for easily updatable user details). Again, Claude provided the CRUD (Create, Read, Update, Delete) boilerplate. I didn't accept it blindly; I reviewed for adherence to my structure, fixed issues, and ensured everything worked through rigorous testing.

File management followed suit. Claude generated the code, but I spotted an outdated AWS SDK version in the output. This was a reminder that AI tools might not always reflect the latest updates. Drawing on my experience, I upgraded it, set up an AWS S3 bucket with a CDN for efficient delivery, and verified functionality.

Courses were straightforward: same process, with minor error fixes leading to a working LMS module.

Messaging proved trickier. Midway through, I hit Claude's chat limit. Undeterred, I had the AI generate a detailed prompt summarizing the project's state, structure, and progress. I pasted this into a new chat session, allowing the AI to pick up seamlessly. The structure shifted slightly at first, but I guided it back on track. In the end, I handled most error resolutions myself, making necessary updates to ensure robust DMs and channels.

Lessons Learned: AI as a Bootstrapper, Not a Replacement

This project reinforced a key insight: AI excels at bootstrapping. It generates standard solutions quickly, handles repetitive tasks, and accelerates development. But it's not infallible. Errors, outdated info, and context loss require human intervention. That's where software engineering shines: knowing what to ask, spotting flaws, and refining outputs.

AI has empowered engineers to become solo founders, pushing products to market at unprecedented speeds. It hasn't made us obsolete; it's elevated us to "god-like" productivity levels. Imagine completing months of work in weeks. That's the reality for those who know how to wield it. A novice "vibe coder" couldn't achieve this; only a skilled engineer can direct AI effectively, avoiding pitfalls and ensuring quality. In my case, AI shaved off boilerplate drudgery, letting me focus on architecture and innovation. The result? A fully functional trading academy API, delivered efficiently.

Conclusion: Embrace AI, But Build Your Foundation First

AI isn't here to replace software engineers. It's here to amplify them. By mastering the fundamentals, you can become a 10x engineer: faster, more innovative, and capable of solo feats that once required teams. My experience proves it: leverage AI for speed, but rely on your expertise for precision.For inquiries, reach out via X at @janvinsha.

Ethereum vs Solana: Understanding Data Storage Differences in Their Ecosystems

Vincent Jande — Wed, 08 Jan 2025 19:04:30 +0000

Introduction
In the rapidly evolving blockchain landscape, Ethereum and Solana stand out as two of the most prominent platforms, each with its unique architecture and capabilities. While both aim to facilitate decentralized applications (dApps) and smart contracts, their approaches to data storage differ significantly. Understanding these differences is crucial for developers choosing the right platform for their projects.

Ethereum's Smart Contract Data Storage
Ethereum, the pioneer of smart contracts, allows developers to store data directly within smart contracts. This capability is intrinsic to Ethereum’s design, where each smart contract is essentially a stateful entity on the blockchain. Developers can define and manage variables within contracts, enabling complex logic and data manipulation directly on-chain.

Storing data within smart contracts offers several advantages:

Simplicity and Cohesion: All related logic and data reside within the same contract, making the development process more straightforward.
Atomic Transactions: Operations on data can be executed atomically, ensuring consistency and reliability.
Rich Ecosystem: Ethereum’s mature tooling and extensive documentation support seamless data management within contracts. However, this approach also has drawbacks. Storing large amounts of data on-chain can be expensive due to gas fees, and it may lead to scalability issues as the blockchain grows.

Solana’s Account-Based Data Separation
In contrast, Solana adopts a different strategy by separating data storage from program logic. Instead of embedding data within smart contracts, Solana uses separate accounts to hold data. These accounts are often Program Derived Addresses (PDAs), which are deterministic and derived from the program’s public key and specific seeds.

Key aspects of Solana’s data storage model include:

Modularity: By decoupling data from program logic, Solana promotes a more modular architecture. Programs can interact with multiple data accounts, enhancing flexibility.
Scalability: This separation allows for more efficient data handling and reduces the overhead on individual programs, contributing to Solana’s high throughput.
Security: PDAs ensure that only the designated program can modify the associated data, enhancing security through deterministic address generation. While Solana’s approach offers scalability and modularity, it introduces complexity. Developers must manage multiple accounts and ensure proper interactions between programs and data accounts. This can increase the learning curve compared to Ethereum’s more integrated model.

Comparative Insights

Performance and Scalability: Solana’s account-based model and high throughput make it suitable for applications requiring rapid transactions and extensive data manipulation. Ethereum, while slower and less scalable, benefits from its established network and robust security features.
Developer Experience: Ethereum’s all-in-one contract data storage is more intuitive for developers familiar with traditional smart contract development. Solana’s separation of data and logic requires a deeper understanding of account management and PDA utilization.
Use Cases: Ethereum excels in scenarios where tight integration of logic and data is beneficial, such as decentralized finance (DeFi) protocols and complex dApps. Solana shines in high-frequency applications like gaming, real-time analytics, and NFT platforms that demand speed and scalability.

Conclusion
Both Ethereum and Solana offer powerful ecosystems for building decentralized applications, but their approaches to data storage reflect different priorities and architectural philosophies. Ethereum’s ability to store data within smart contracts provides simplicity and cohesion, making it ideal for a wide range of applications. On the other hand, Solana’s separation of data into PDAs and other accounts enhances scalability and performance, catering to high-throughput demands.
For developers, the choice between Ethereum and Solana hinges on the specific requirements of their projects. Understanding these key differences in data storage is essential for leveraging each platform’s strengths and building efficient, scalable, and secure decentralized applications

A Lesson in Simplicity: Sorting Files Like a Pro in an Interview

Vincent Jande — Tue, 29 Oct 2024 14:30:39 +0000

During a technical interview for a full-stack developer role, I found myself in a familiar yet unexpectedly challenging situation. Everything had been going smoothly until the interviewer presented me with a task that seemed simple at first.

“Can you sort these filenames the way they’d appear in a file explorer, in ascending order?” they asked.

I thought, “Piece of cake.” Sorting is such a fundamental operation that I didn't expect any trouble. But as soon as I started writing the code, I hit a snag. The filenames were all over the place some were simple, but others included numbers, letters, and combinations of both.

I tried using a basic string sorting method like:
array.sort();
But this produced an odd result. The numbers were sorted lexicographically (meaning “10” would come before “2” because it starts with a “1”), and mixed alphanumeric strings weren’t in the correct order. It was a mess, and it didn’t resemble the natural order you see in file explorers at all.

I could feel the clock ticking and pressure building up. I tried to work through various custom comparison functions to handle the numbers properly, but nothing seemed to click.

Then, I remembered a simple trick I had read about not too long ago: localeCompare.

localeCompare allows you to compare strings in a way that mimics how humans sort things. By using it with the numeric option, it handles the numbers as actual numbers rather than comparing them as text. Here’s the code I used:
array.sort((a, b) => a.localeCompare(b, undefined, { numeric: true, sensitivity: 'base' }));
This single line of code sorted the filenames exactly like a file explorer would: numbers were ordered naturally, and letter/number combinations were handled seamlessly.

As soon as I ran the code, I saw the correct order appear on the screen. The filenames were perfectly sorted in ascending order, just like in a file explorer. I smiled as I explained the solution to the interviewer, who seemed pleased with how I resolved the issue.

What initially felt like a complicated problem ended up being solved with a simple, elegant solution. It was a reminder that sometimes the most effective tools are the simplest, and knowing those small tricks can make all the difference.

Debugging WebSocket Connection Failure: wss://relay.walletconnect.org

Vincent Jande — Thu, 24 Oct 2024 15:01:34 +0000

If you've encountered a WebSocket connection failure when trying to use WalletConnect with an error like:
WebSocket connection to 'wss://relay.walletconnect.org' failed
this error might be linked to access restrictions applied by certain services to specific countries, including Nigeria.

Understanding WebSocket and WalletConnect

WalletConnect is an open protocol for connecting decentralized applications (dApps) to mobile wallets through QR code scanning or deep linking. It relies on WebSocket (WS) connections to relay encrypted communication between the dApp and the wallet. The WebSocket protocol, denoted by the wss:// scheme (secure WebSocket), is crucial for maintaining a persistent connection between the client and server for real-time interactions.
However, you might encounter the WebSocket failure for the relay.walletconnect.org endpoint due to geo-blocking. Some platforms, including WalletConnect's relayer, restrict access to certain countries like Nigeria, potentially due to regulatory compliance or risk management strategies.

Common Symptoms

Connection Timeout or Failure: When initiating the connection to wss://relay.walletconnect.org, the WebSocket handshake fails.
Inconsistent Behavior: The issue may persist across different networks and devices in Nigeria but may work without problems when using a VPN or accessing the service from a different location.
Country-Specific Restrictions: WalletConnect's relay servers could be enforcing geo-blocks, resulting in connection denials for users based in regions with restricted access.

Workarounds

If you're facing this error, there are a few options to explore:
Use a VPN: A simple but effective solution is using a VPN to connect from a country where WebSocket connections to WalletConnect relayers are not blocked.
Proxy Services: Set up a proxy server in an unrestricted region to relay the WebSocket connection on your behalf.

In conclusion, this issue highlights the importance of understanding country-specific restrictions when developing or using Web3 tools. While frustrating, using a VPN or alternative relayer services can help you work around the problem.