As a self-taught builder walking the 90-day Web3 path, I recently stopped staring at the charts and decided to build a functional Proof-of-Work (PoW) Mining Engine from scratch using Node.js.

What I discovered wasn't just a lesson in cryptographic primitives—it was an accidental masterclass on life itself. Let's break down the architecture, lines of code, and the philosophy behind them.

🏗 1. The Mempool: Life’s Lobby of Unfulfilled Promises

Before a transaction becomes immortalized on the blockchain, it sits in a temporary buffer called the Memory Pool (Mempool).

const mempool = [];
const blocks = [];

function addTransaction(transaction) {
    mempool.push(transaction);
}

Think of the mempool as that mental list of things we plan to do "someday"—the gym subscription, the book we want to write, the texts we left on read. They float there in an unconfirmed void, waiting for a validator (or sheer willpower) to pick them up and turn them into reality.

In my node implementation, addTransaction simply pushes raw data into this digital waiting room. It's cheap, it's easy, and it requires zero effort. But as we know, ideas are free; validation is expensive.

✂ 2. The Atomic Choice: Splicing Reality

A miner cannot process everything at once. Memory is finite, and so is time. To prevent exhaustion attacks, we must set boundaries.

const MAX_TRANSACTIONS = 10;

function mine() {
    const transactions = mempool.splice(0, MAX_TRANSACTIONS);
    const block = {
        id: blocks.length,
        transactions: transactions,
        nonce: 0,
    };

By using .splice(0, MAX_TRANSACTIONS), my mining engine simultaneously slices out the top 10 pending transactions and removes them from the global mempool.

This is a beautiful architectural necessity. In blockchain, it prevents the same transaction from being mined twice (double-spending). In life, it’s called focus. You cut out a few specific tasks from the chaotic pile of possibilities, lock them into a container, and say, "I am dealing with exactly this right now."

🌀 3. The while(true) Loop: The Ultimate Philosophical Trap

Here comes the engine room. To seal the block, the miner must solve a cryptographic puzzle: finding a hash lower than a pre-defined TARGET_DIFFICULTY.

const SHA256 = require('crypto-js/sha256');
const TARGET_DIFFICULTY = BigInt(0x0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);

while (true) {
    const blockString = JSON.stringify(block);
    const blockHash = SHA256(blockString);
    const hashInt = BigInt(`0x${blockHash}`);

    if (hashInt < TARGET_DIFFICULTY) {
        block.hash = blockHash;
        break; 
    }
    block.nonce++;
}

Look at that while (true) statement. It is the absolute definition of insanity—doing the exact same thing over and over again, hoping for a different result.

Except, it’s not exactly the same. Every time the loop fails to hit the difficulty target, we increment a tiny, seemingly insignificant variable called the nonce.

block.nonce++;

The data in the block (the past) remains unchangeable. The target (the world's standard) remains unyielding. The only thing the miner can control is the nonce—a random variable of entropy.

Isn’t that human resilience in a nutshell? You try, you fail, the universe rejects your hash. You don't rewrite your history; you just tweak your internal variable (nonce++) and spin the wheel again. You keep doing it until the mathematical alignment clicks, and you break out of the loop.

🧠 4. Enter BigInt: Because JavaScript Has Commitment Issues

When dealing with a 256-bit cryptographic hash output, standard JavaScript numbers simply have a nervous breakdown. They cannot handle numbers that large without losing accuracy.

To compare our generated hash against the strict TARGET_DIFFICULTY, I had to cast the hexadecimal output into a BigInt :

const hashInt = BigInt(`0x${blockHash}`);

There’s a silent design lesson here: Choose your scale wisely. When your ambitions or your data structures grow larger than life, the standard tools of your everyday comfort zone will fail you. You need to upgrade your data types to handle the heavyweight realities of the network.

🏆 Final Thoughts: No Good Intentions, Just Proof

Once the target is hit, the block is appended to the ledger, and the state updates.

The most profound realization from building this? The blockchain network doesn't care how hard the miner's CPU worked. It doesn't care if the loop ran 5 times or 5 million times. It only cares about the final block.hash that proves the work was done. It's deterministic, cold, and transparent.

In a world full of superficial promises and digital noise, maybe that's why Web3 feels so intoxicating. It’s a space that bypasses politics and handshakes. It demands a literal Proof of Work.

I am mapping my 90-day Web3 architecture sprint live on the blockchain. Track my daily commits and raw logic over on GitHub.