I Thought Building a Simple Web3 Tool Was the Hard Part (It Wasn’t)

john Smith — Sat, 02 May 2026 02:47:30 +0000

A few months ago I started building a small tool on Solana.

Nothing crazy.

Just something that lets you:

create a token
attach metadata
add liquidity
and actually use it

That was the idea.

Keep it simple.

The Plan Was Pretty Straightforward

I didn’t want to build another “platform”.

No custody.
No custom smart contracts I fully control.

Just an interface that prepares transactions and lets users sign everything in their wallet.

Basically:

backend prepares → wallet signs → chain executes

In my head, that felt clean and simple.

The First Reality Check

The blockchain part wasn’t the hard part.

Creating a token? fine
Sending a transaction? fine

The problems started when everything had to work together.

Everything Around the Chain Is… Messy

You don’t just “create a token”.

You end up dealing with:

metadata uploads (IPFS, gateways, broken links)
DEX integrations (each one slightly different)
APIs that don’t behave consistently
rate limits you don’t control
random failures you can’t reproduce

Some days it felt like:

API returns 200 → empty data
retry → works
retry again → rate limited

No real logic behind it.

I Had to Add a Backend Proxy

At first I was calling everything directly from the frontend.

Bad idea.

Moved everything into a Node/Express backend:

transaction building
DEX calls
metadata handling

That alone made things easier to reason about.

At least all the chaos lives in one place now.

“Non-Custodial” Sounds Simple (It’s Not)

“Users sign their own transactions” sounds great.

But it changes everything.

you don’t control execution
you can’t easily retry
you depend on wallet behavior
UX gets tricky fast

If something fails, you can’t fix it for the user.

You just… try again.

Rate Limits Became a Real Issue

Some endpoints were getting hit way more than expected.

So I added:

per-wallet limits when possible
fallback to IP

Then Redis wasn’t always available.

So I added a memory fallback.

Not perfect, but at least things don’t break.

External Services Are Not Reliable

For token images / metadata I used:

Uploadcare
Pinata (IPFS fallback)

Different formats everywhere:

ipfs://...
gateway URLs
CDN links

At some point I just gave up trying to “support everything properly”.

Now everything gets normalized on the backend.

One format. One output.

Less surprises.

The Part I Didn’t Expect

I thought I’d spend most of my time on:

blockchain logic
token creation
transactions

I didn’t.

Most of the time went into:

handling weird API responses
fixing edge cases
retry logic
cleaning inconsistent data

The glue code is the real work.

When It Started to Feel Different

There was a moment where nothing visually changed…

but the codebase felt different.

Less fragile.
Less “don’t touch this part”.
More predictable.

That’s when I knew it was actually improving.

Something I Really Didn’t Expect

I thought once the tool worked, builders would just… start using it.

That didn’t happen.

Finding Builders Is Way Harder Than Building

I tried a few things:

posting on Twitter
sharing in communities
reaching out to people

Most of it either gets ignored or feels forced.

And honestly, I get it.

There’s a lot of noise in Web3.

People don’t just switch tools because something new exists.

Even if it’s better.

What I’m Starting to Realize

It’s not really about “finding users”.

It’s more like:

being where builders already are
understanding what they actually need
not overbuilding before that

Right now I’m not aiming for 100 users.

I’d be happy with 2–3 real builders using it and telling me what’s broken.

Where It’s At Right Now

It works.

Not perfectly, but:

tokens can be created
transactions are signed in the wallet
liquidity can be added
no funds are ever held

That was the core goal.

Final Thought

Building in Web3 isn’t just about the chain.

It’s about everything around it.

unreliable APIs
wallet UX
edge cases
user behavior

The chain is actually the most predictable part.

If you’ve built something similar, I’m curious:

how did you handle unreliable APIs?
did you struggle getting real users early on?

Still figuring this out as I go.

Dev Journal — Building a Non-Custodial Token Tool on Solana

john Smith — Wed, 29 Apr 2026 00:01:02 +0000

Day 3

Added a proxy layer for external calls.

Everything goes through backend now:

DEX interactions
quotes
token stuff

Why
Didn’t want the frontend juggling 5 APIs directly.

Problem
External APIs are unreliable.

Sometimes:

random 500
sometimes 429
sometimes just empty responses

Decision
Centralize everything in the proxy and handle retries there.

Dev Journal — Building a Non-Custodial Token Tool on Solana

john Smith — Tue, 21 Apr 2026 00:03:54 +0000

Day 2

Worked on the token creation flow.

built /api/create-token
backend prepares transactions
frontend signs via wallet (Phantom)

Why
I wanted to keep everything non-custodial.

Problem
Where does signing actually happen?

At first I was mixing things:

some logic frontend
some backend

It got messy fast.

Decision
Backend builds → wallet signs → that’s it.

No exceptions.

Dev Journal — Building a Non-Custodial Token Tool on Solana

john Smith — Fri, 17 Apr 2026 00:04:24 +0000

Day 1

Started by figuring out the overall architecture.

Went with:

Next.js for the frontend
Node/Express as a backend proxy
MongoDB for anything off-chain

Didn’t want to write custom smart contracts right away. Too much overhead. So I decided early:

→ use native SPL tokens
→ plug into existing DEXs (Orca / Raydium)

Why
I’m not trying to rebuild the ecosystem. Just orchestrate it.

Problem
Too many choices for DEX integrations. Nothing standardized.

Decision
Start with Orca (simpler), keep Raydium as fallback.

I built a non-custodial token launcher on Solana

john Smith — Sat, 11 Apr 2026 23:27:43 +0000

Designed to connect with DEXs like Raydium

This is not just an idea — it's already functional and evolving.

What I’m trying to solve is not speed.

It’s structure.

Launching fast is easy.

Launching properly is not.

If you're building in Web3 or have worked with Solana,
I’d be interested in your feedback.

And if you're the kind of builder who likes shipping real products,
feel free to reach out.

Forem: john Smith

I Thought Building a Simple Web3 Tool Was the Hard Part (It Wasn’t)

Dev Journal — Building a Non-Custodial Token Tool on Solana

Dev Journal — Building a Non-Custodial Token Tool on Solana

Dev Journal — Building a Non-Custodial Token Tool on Solana

I built a non-custodial token launcher on Solana