🚪 Join Blurt Grew Up: From Proof of Concept to v1.0.0-rc.1

<center </center

Hello Blurtians!

Twenty days ago, Join Blurt Blockchain was still what I affectionately called one of my favourite POC proof of concepts .

Today, its source code is public and its first release candidate exists:

Join Blurt v1.0.0-rc.1

That sentence looks simple.

The journey behind it was anything but simple. 😂

In my previous post, How a Simple Question Led to blurt-claude-code, I explained that the framework needed to leave the comfort of architectural discussions and face a real Blurt project.

For that first experiment, I chose Join .

I expected an audit.

I expected to find weaknesses.

I expected a few difficult decisions.

What I did not expect was to spend the next twenty days turning almost every part of the original proof of concept into something stronger, safer and much closer to the application I had imagined from the beginning.

Forty-two commits later, Join has grown up.

---

<center </center

The POC had proved the idea

When I introduced Join Blurt Blockchain in December 2024, the goal was clear:

Make creating a Blurt account feel simple, intuitive and welcoming.

The proof of concept demonstrated that a newcomer could choose a username, generate their keys and pay for account creation using assets from Blurt's sister blockchains.

It also explored referrals, coupons and several payment options.

That was enough to prove the product idea.

But proving an idea and operating a reliable onboarding application are two very different things.

The POC had accumulated experimental code, unfinished paths and assumptions that had never been challenged deeply enough. Some parts worked, but they did not yet form one coherent and durable system.

So this time, I did not start by asking:

"Which new feature should I add?"

I started with a much less exciting question:

"What must always remain true, even when something goes wrong?"

That question changed the entire project.

---

<center </center

A complete account-creation journey

Join now guides a newcomer through one continuous journey:

1. Choose an available Blurt username 2. Generate and save the account keys locally 3. Choose a payment chain and asset 4. Follow payment detection and irreversible confirmation 5. Receive a funded Blurt account 6. Discover what to do next

The user's private keys never leave the browser.

Join receives only the selected username, the four public account keys and a narrowly scoped referral transaction signed locally by the future account. That transaction is fixed in advance and cannot be repurposed by the server.

The Master Key backup must be downloaded before the journey can continue, because simplifying onboarding should never mean hiding the importance of account ownership.

The new account is also funded with a configurable starting BLURT balance, so the newcomer does not arrive with an empty wallet and no way to begin interacting.

This is the visible part of Join .

Behind it, the project has changed even more.

---

<center </center

Three payment chains, one destination

A new Blurt account can now be paid for through:

- Blurt with BLURT - Hive with HIVE or HBD - Steem with STEEM or SBD

Manual transfers are always available.

Depending on the selected chain and the extensions installed in the browser, Join can also assist the payment through Hive Keychain , Steem Keychain or WhaleVault .

The important part is what happens after clicking a wallet button:

The wallet never decides whether the payment was received. The blockchain does.

A successful wallet callback only means that the transfer request was submitted. Join 's server independently follows the selected chain, finds the exact transfer through its unique memo and waits until it becomes irreversible.

Whichever asset is used to pay, the destination remains the same:

The account is always created and funded on Blurt.

This makes Join a real bridge for people who already belong to the wider Graphene ecosystem and want to discover Blurt without first finding a separate way to acquire BLURT.

---

<center </center

Payment is no longer a temporary browser event

One of the biggest changes is invisible until the browser is refreshed, closed or disconnected.

In the original POC, too much of the journey depended on the page remaining alive.

That is no longer true.

Join now creates a durable Order before the payment page opens. Its authoritative state lives in SQLite, while an HttpOnly recovery cookie lets the same browser return to it without storing private keys.

Closing the payment window does not stop payment detection.

Refreshing the page does not lose the Order.

Restarting the Join server does not forget the ingestion checkpoint or provisioning progress.

Payment attempts are immutable and individually traceable. If a user cancels one method and selects another, the old memo is not erased or forgotten. Join continues draining its payment window safely, and any late transfer becomes an explicit incident rather than accidentally creating the account twice.

Across every rail and every attempt:

Only one accepted payment can win, and the Blurt account can only be provisioned once.

That sounds obvious.

Making it remain true during retries, process restarts, wallet ambiguity, late transfers and competing browser tabs was considerably less obvious. 😅

---

Following chains means respecting their reality

Blockchain payments are not ordinary API responses.

A transfer can first appear in a reversible block. A fork can replace that block. RPC endpoints can fail, recover or even be accidentally reconfigured toward another network.

Join now treats these conditions as part of normal blockchain engineering rather than exceptional afterthoughts.

Each activated payment rail has one demand-driven ingestion supervisor that:

- follows blocks sequentially; - records reversible inclusion; - waits for irreversible confirmation; - handles ordinary fork invalidation and replay; - preserves durable checkpoints across restarts; - binds obligations to the discovered identity of the network; - refuses to replay work when endpoints no longer represent the network that produced it.

The final hardening pass fixed two especially important invariants:

1. Network identity is executable state. A Hive, Steem, mainnet, testnet or fork identity cannot be silently substituted while obligations are still in flight. 2. Finality remains tied to the origin that proved the chain. After a pool rebind, pending blocks must be proven again under the current reading origin before an irreversible transfer can be emitted.

These are not glamorous homepage features.

Most users will hopefully never notice them.

That is exactly the point.

Reliable onboarding should feel simple because the complexity is handled underneath — not because it has been ignored.

---

<center </center

Join now continues after account creation

Creating an account is only the beginning.

A newcomer immediately has questions:

What is Blurt?

Why are there four keys?

Which key should be used for publishing?

How should those keys be backed up?

How does the wallet work?

Where can someone publish, watch videos, microblog, inspect blocks or ask for help?

<center </center

This is why Join now includes a complete beginner guide:

1. Understanding Blurt 2. Understanding the four keys 3. Backing up and protecting your keys 4. Publishing and interacting 5. Using the Blurt Wallet 6. Discovering your first dApps 7. Blurt and AI 8. FAQ

The guide does not merely explain buttons.

It introduces the ideas a new user needs to become confident and autonomous: account ownership, Blurt Power, transaction fees, rewards, witnesses, recovery, safe signing habits and the role of the different applications around the blockchain.

Join also has a curated Blurt Ecosystem directory presenting fifteen useful destinations across blogging, microblogging, video, wallets, security, explorers, community tools, AI and exchanges.

<center </center

- Guide: - Ecosystem:

The objective is no longer simply:

"Your account has been created. Goodbye."

It is:

"Welcome to Blurt. Here is how to start growing your audience, your Blurt Power and your place in the ecosystem."

---

<center </center

Twelve languages, including the public content

Join already supported twelve interface languages during the POC.

This release goes much further.

The complete account-creation funnel, guide, FAQ, ecosystem directory, privacy information and legal surfaces have all received a new translation pass in:

- Deutsch - English - Español - Français - Italiano - Português - 日本語 - 한국어 - ไทย - Русский - Nederlands - 中文

The editorial pages use stable localized URLs such as /guide/fr , /guide/de and /guide/zh , with server-side rendering, reciprocal hreflang , localized metadata and sitemap entries.

This matters for usability, but also for something broader:

People should be able to discover Blurt through search in their own language before they already know that Blurt exists.

International onboarding does not begin at the language selector.

It begins at discovery.

---

<center </center

Built for people, search engines and AI agents

Publishing in twelve languages would mean little if those pages were slow, inaccessible, difficult to crawl or opaque to the tools people increasingly use to discover the web.

This is why Join’s public surface received the same attention as its account-creation journey: server-side rendering, semantic HTML, stable canonical URLs, reciprocal hreflang , localized metadata, structured data, sitemap entries and clear crawling rules.

Join also provides llms.txt and llms-full.txt , giving AI agents a machine-readable path toward canonical resources, security boundaries and accurate project information — without turning its stateful payment workflow into an autonomous agent API.

<center </center

On the audited production page, Google Lighthouse returned:

- 100 Performance - 100 Accessibility - 100 Best Practices - 100 SEO - 3/3 Agentic Browsing

A Lighthouse report is a snapshot, not a permanent certificate. But it is a useful signal that performance, accessibility, discoverability and agent compatibility were treated as foundations rather than afterthoughts.

Being multilingual matters. Being discoverable and understandable — by people, search engines and the agents increasingly assisting them — matters just as much.

---

<center </center

The experiment behind the project

Join also became the first serious real-world test of the engineering framework I introduced in my previous post.

It did not turn one AI assistant into a magical developer that built everything alone.

The interesting result was almost the opposite.

Different AI agents and harnesses each played a distinct role: exploring the repositories, challenging architectural boundaries, auditing protocol assumptions, implementing focused changes, reviewing security invariants, improving documentation, translating editorial content and creating the visual world of the guide.

The shared Blurt engineering context helped those discussions begin from the same principles:

- repositories remain the implementation source of truth; - Blurt Layer 1 remains the semantic authority; - reusable capabilities and application policy should not be confused; - compatibility and failure behaviour must be reasoned about before code is accepted.

None of this changed my usual role. As an architect and IT director, I was doing what I already knew: setting the direction, making decisions and orchestrating specialists. The difference was that instead of leading a human team, I was leading AI assistants.

Every major step was read, tested, questioned and sometimes sent back for another pass. More than once, a technically cautious sentence had to be rewritten because being technically defensive is not an excuse for making Blurt sound discouraging or obscuring how the protocol actually works.

That balance became one of the most valuable parts of the experiment:

Use AI to extend your ability to inspect, challenge and create — without surrendering the identity, judgement and intention that make the work yours.

This is exactly the philosophy now explained in Join 's new Blurt and AI chapter.

---

Tested far beyond the original POC

The final release-candidate validation included:

- 1,155 unit and integration tests passed - 105 Playwright end-to-end journeys passed - production build; - browser-bundle boundary verification; - generated documentation freshness; - secret scanning; - complete cold HIVE and STEEM payment journeys.

The end-to-end environment is hermetic. It uses controlled Graphene fixtures and mock chains, so the suite can exercise payment detection, irreversibility, provisioning and restart recovery deterministically without spending real funds.

Tests do not prove that software is perfect.

They do make it much harder for a future change to quietly break the invariants we have spent these twenty days building.

---

The repository is now public

For the first time, the complete Join repository is publicly available:

The project is released under GPL-3.0-or-later .

The repository includes the application, tests, deployment guide, security policy, architecture decisions and the reasoning behind the payment and provisioning model.

Making the repository public is not only about transparency.

It means developers can now audit the assumptions, reproduce the test environment, report problems and help improve Blurt's onboarding surface.

Join was created on my own initiative to improve onboarding on Blurt. It is independently developed and, as such, is not presented as an official Blurt Foundation dApp.

It is now an open invitation to build with me.

---

<center </center

What comes after Join?

As always, the part that interests me most is tomorrow.

Join now provides a better entrance to Blurt. But onboarding should not depend solely on newcomers finding that entrance and paying the entire cost themselves.

A community may want to welcome new members. A creator may introduce their audience to Blurt. A dApp may launch an onboarding campaign. A sponsor may decide to fund accounts and give newcomers enough BLURT to begin their journey.

Some of those possibilities already exist within Join.

When sharing its link, remember to include your referral account and a campaign identifier:

The r= parameter identifies who introduced the newcomer, while cid= identifies the campaign or channel through which they arrived. This attribution will later be anchored on Blurt.

💡 Tip: Join identifies a payment through its recipient, exact amount and unique memo. The person requesting the account does not have to be the person paying for it. Someone can choose their username and securely save their keys, while a friend, community or sponsor completes the displayed transfer on their behalf — provided the payment instructions are copied exactly.

Today, this kind of sponsored onboarding can already be coordinated manually.

Tomorrow, Invite will turn it into a complete affiliation platform for the Blurt ecosystem.

Invite will bring together sponsors, campaigns, coupons, referral credits, budgets and bonus policies. It will make it possible to decide who funds an account, how much support a newcomer receives and which initiative made that onboarding possible — while Join remains the simple and welcoming experience presented to the user.

But Invite will not stop at funding invitations.

It will also make their impact visible.

By combining the referral and campaign attribution recorded on-chain with the public activity indexed by Nexus, Invite will provide analytics showing how many invitations became accounts, how many referrals remained active, how much they published and which rewards were generated across the network.

Referrers, communities and dApps will be able to compare campaigns through their cid= , understand which channels create lasting participation and follow their contribution to Blurt's growth.

Not merely how many people clicked a link.

But how many joined, became active, started publishing and found their place on Blurt.

Public dashboards and The Vanguard will also highlight the people and initiatives bringing new voices to the blockchain — using transparent on-chain activity rather than an opaque analytics system.

That is what comes after Join.

Not a larger account-creation form, but the infrastructure required to fund, coordinate and measure onboarding across the ecosystem.

Join opens the door. Invite will help the ecosystem hold it open — and show how far every invitation travels.

And that is the chapter I want to build next.

---

<center @nalexadre <div <i Top 20 Witness • Builder • Architect</i </div </center

---

<center </center

Building the Blurt ecosystem

Producing blocks is only one part of my contribution to Blurt.

I spend most of my time analysing, designing, building and experimenting with ideas that help strengthen the Blurt ecosystem over the long term.

Useful links

- Join Blurt → - Join source code → - BeBlurt frontend → - Public RPC node → - dBlurt TypeScript SDK documentation → - Blurt MCP documentation → - More source code: - -

Backing my Witness

If you appreciate the work I am doing for the Blurt ecosystem, supporting my witness is one of the easiest ways to help.

Every Blurt account can vote for up to 30 witnesses , and even though I am already in the Top 20, every vote helps strengthen the long-term sustainability of the infrastructure I maintain.

- via BeBlurt → - via Blurt Wallet →