<![CDATA[Indie Hacker .Work]]>https://hashnode.huynhnhanquoc.comRSS for NodeSat, 11 Apr 2026 14:35:04 GMT60<![CDATA[The Dream of Indie Coders]]>https://hashnode.huynhnhanquoc.com/the-dream-of-indie-codershttps://hashnode.huynhnhanquoc.com/the-dream-of-indie-codersMon, 03 Nov 2025 22:59:28 GMTA Kindred Spirit

It’s been a long time since I talked to someone who shares the same wavelength.
Even though our conversation was only online, it felt as if we could clearly see each other’s path.

We met through a thread.
I don’t know what to call this relationship.
Maybe, since we first encountered each other in a BuildInPublic group, we could call ourselves indie hackers.

But why do I title this piece “The Dream of Indie Coders”?
Perhaps it’s because of where we come from.
We are young people chasing our own dreams, feeling alive when we code and follow our passion.

We might have to work harder than others to reach what we truly desire — that is, to live fully within our own dream.

Vanilla JS and Early Ambitions

Lately, I’ve met many developers still using Vanilla JS.
While most run after frameworks, we choose a different path.

Five years ago, I returned to Tam Kỳ and began coding the purest version of my dream — with Golang and Vanilla JS.
Recently, I started releasing a small library (or framework, depending on how you see it) called Kit JS.

Yet, I want to preserve the purity, the raw power of Vanilla JS, carrying it forward while combining it with SSR capabilities.

I didn’t write this library to compete or change the world.
I just wanted to reconnect with the original strength of these languages — a way to remember where I came from.

Like the story of backend languages trying their hand at frontend — it can work in some ways, like with WebAssembly — but it’s not everything, and certainly not a complete full-stack solution.

I once thought deep learning in programming meant mastering frameworks or flashy languages like TypeScript.
But the more I code, creating small libraries to solve simple tasks, the more I realize:

“Learning deeply is learning the fundamentals first.”

Today

Today is a rushed coding day.
I am expanding the core of Kit JS and deleting lines of code I spent hours writing — much like the ninth time I refactor my Golang system.

I used to ask myself:

“Who will recognize this? Who will pay for this?”

Now, I no longer seek an answer.
My heart has already answered.

Sometimes, a developer’s happiness is simply sitting in a café, amidst bustling people, yet keeping a heart fully devoted to passion.
Sunlight kisses the streets, and a foolish dream is guided by the heart.

We — Seekers of Tiny Happiness

We chase ambitions, smiles, and a small happiness in every line of code.
Every tiny snippet contributes to the world beyond our screens.

I’ve asked myself:

“Why do I exist in this world?”

Perhaps many coders have asked the same.
If we had a “platform” handed to us, would we still dare to dream?

Tomorrow, the sun will bloom again — like a flower spreading its fragrance across the sky.
Just like us, still seeking our own happiness.

That happiness might just be a small dream — of one or many indie coders.

Code, Low-Code, or No-Code at All

The world remains beautiful — beautiful because we can draw our dreams in code.

I will step outside and enjoy a sunny day.
The sun still dreams, and the code keeps flowing.

Clouds — true to their name — are just clouds.
And perhaps life, too, drifts along those clouds.

We are just small developers, seeking happiness in coding, contributing, and leaving a mark in the world.

Out there, some have fame, titles, and recognition.
We — the foolish ones — only have hearts that resonate and mutual respect for our craft.
I have always looked up to Linus as a giant in that sense.

Hearts of Laughing Fools

Today, the wind may not stir the trees, but sunlight peeks through after a sudden rain.
If we could, we would code for a lifetime.

He once told me:

“The happiest days are Friday and Saturday — the days I get to do something just for myself.”

I am luckier — I don’t “sell myself,” because I indulge my foolish heart and make it suffer sometimes.
But neither of us has another choice.
Because we have no “platform.”

Ah, yes — we do.
Our platform is the dream — the dream of foolish indie coders, delightfully naive.

I always hope that other builders will keep moving forward.
Step by step.

If you walk towards the sun, you will feel its warmth.
And if you walk against the sun, the light will still follow.

Every step has a reason to begin.
And perhaps, we all started somewhere — with a small dream.

— Written on a sunny morning, with keystrokes echoing in rhythm with the heartbeat.

NOTES

More about me:

Thanks for reading Huỳnh Nhân Quốc’s article! Subscribe for free to receive new posts and support my work.

]]><![CDATA[The Indie Path]]>https://hashnode.huynhnhanquoc.com/the-indie-pathhttps://hashnode.huynhnhanquoc.com/the-indie-pathMon, 03 Nov 2025 22:43:56 GMTThe Dream of Technological Independence

I remember it clearly — sitting in a tiny café, looking at my own hands and asking:

“What am I really looking for?”

No one answered. All I knew was that if I had nothing to lose, then everything left was an opportunity to start over.

By day, I delivered packages. By night, I wrote code. Each delivery earned fifteen thousand dong — enough for a cup of coffee and a few more lines of clumsy code. Day after day, this loop repeated: deliver, code, deliver, code. Life was small, but it felt pure in a strange way.

Looking back, I realized that those days taught me the most important lesson: big dreams don’t begin with leaps; they begin with slow, small steps.

Golang and the Dream of a Fool

I dabbled in many languages — Rust, Python, JavaScript. But I chose Golang. Not because it was the most powerful, but because it was simple and honest. Within that simplicity, I saw myself — a fool believing in small things.

I started from scratch: learning syntax, practicing routers with mux, exploring fiber, writing a DNS, thinking about pointers and how they traveled through templates. Some nights I would lie on an old chair, staring at the ceiling, pondering how a pointer could maintain its value across page layouts. I didn’t know why I thought so deeply; all I knew was I wanted to understand everything to the core.

No mentors, no guides — just me and the computer. Every wrong line, every bug fixed, was a lesson. Gradually, I realized that the most important thing wasn’t the results, but the feeling of laying the first bricks of a dream yet to take shape.

SSR — Returning to the Original Dream

I started with the web. And perhaps the web is what kept me hooked on programming to this day. From the first HTML tags, a few clumsy CSS lines, copied JS snippets, to Angular, Firebase… I went in circles and eventually returned to the starting point, where everything boiled down to a simple function:

add(a, b) => a + b

I began building an SSR system using Golang templates, experimenting with pointer inheritance between pages and layouts. Once, I sat in a café, laughing and showing my brother the DNS system I’d just built. It only returned an ID, that’s all. Yet in that ID, I saw an entire dream.

I dreamed of a system capable of managing thousands, millions of websites — all connected, centralized, and SEO-optimized. I dreamed of a platform that could deliver content to everyone, gently and efficiently.

Working with SSR, I realized something many modern frameworks forget: the web isn’t about complexity, it’s about improving experiences. Programming doesn’t always have to be grand. Sometimes, it’s just the journey to rediscover the purity of “adding one thing” to a web page that already exists.

JavaScript and Dreams

I don’t recall exactly when I learned JavaScript. Maybe after Golang. Before that, I knew TypeScript, worked with Angular, but never truly understood JS — until I discovered Web Components.

I saw a different world. JS didn’t need frameworks to be powerful. Vanilla JS — simple and free — gave me a sense of true mastery. I sometimes wondered:

“Are JS frameworks just flawed versions of JavaScript itself?”

I grew tired of tiny programs requiring thousands of node modules. I began writing my own web components to enhance SSR-rendered websites. And eventually, I returned to an idea from my C# days: two-way binding.

From those nights, Kit JS was born.

Kit JS isn’t a framework meant to compete. It’s how I tell my story. It bundles everything I’ve learned, believed in, and lived through — from reactive programming, define, reference, to inheritance. To me, Kit JS is more than code; it’s a message:

“Understand technology before depending on it.”

Openness and the Indie Path

About a year ago, I heard the term “indie hacker.” I’m not exactly one, because making money wasn’t my goal. I just wanted to code, share, and connect with others who carried the same spark.

I like to call myself an indie-stack developer — someone walking an independent path, self-taught, building, and rewriting what I need. I started open-sourcing snippets from real projects, turning them into small packages that others could use.

I began blogging, sharing more. Every post, every line of code, every package is part of that dream — the dream that somewhere, someone might find inspiration in my journey and continue building their own.

If no one paves the way, our first lines of code become the path.

The dream of technological independence isn’t about creating a million-dollar product. It’s about understanding technology, being free with it, and letting it bridge passion with real value.

I’m still on that journey. Every line of code, every word I write, is a small but steady step. And I know, no matter how the world changes, I will remain a dreamer with an old laptop and a flower on the keyboard — a fool who believes that with a dream, we can create an entire world.

NOTES

More about me:

Thanks for reading Huỳnh Nhân Quốc’s article! Subscribe for free to receive new posts and support my work.

]]><![CDATA[Directive Sync – The “Odd” Story of Kit JS]]>https://hashnode.huynhnhanquoc.com/directive-sync-the-odd-story-of-kithttps://hashnode.huynhnhanquoc.com/directive-sync-the-odd-story-of-kitMon, 03 Nov 2025 22:40:45 GMTThe Idea Emerges

When I started developing Kit JS, I ran into a problem that most JS frameworks tend to ignore.

My website was SSR-rendered (server-side rendering). Everything was already in the HTML; SEO was ready. But when I tried to pass state or scope from the client back into these rendered elements, the entire component would re-render.

And I realized: I didn’t want to redraw the world. I just wanted to sync the data.

From that realization, Directive Sync was born.

Sync – A Different Rhythm of Data

If a model is the way a framework pushes state to the view, sync is the way the view talks back to the state — a closed loop without destroying or rebuilding the DOM.

In other words, sync doesn’t “recreate,” it listens and records.

Directive Sync wasn’t designed to oppose the model; it’s a natural evolution in the SSR context.
It allows server-rendered pages to behave like lightweight SPAs, without sacrificing SEO, speed, or the static nature of the page.

Why Sync is Needed

In most frameworks, if you want two-way binding, the framework must control the entire DOM.

This means that when HTML is rendered from the server, the framework must re-render on the client to establish bindings. The result:

  • SEO bots see the raw HTML, not the actual state.
  • Users see a “flash” during re-render.
  • We end up running client and server as two separate worlds.

Sync solves this by injecting values from the already-rendered DOM back into the scope.
No re-render, no DOM diffing — just reading the real data from the server and keeping it consistent.

The Philosophy Behind Kit JS and Directive Sync

Kit JS wasn’t created to replace other frameworks.
It emerged from a very specific need: to bridge the static and dynamic worlds, SSR and reactive UI.

It’s not a “new framework idea” — it’s a counterflow mindset:

If the data is already there, why redraw it?

Sync embodies that philosophy — simple, practical, and respectful of what already exists.
It doesn’t claim DOM ownership or force you to “rerun” your app. It quietly synchronizes everything so that it continues to work as it should.

A Small Piece of a Larger Journey

For me, Kit JS isn’t a framework race.
It’s a personal journey to rediscover minimalism in web development.

Directive Sync is just one piece — a slightly “odd” piece because it doesn’t follow pure reactivity. Instead, it blends static rendering with dynamic data life.

And perhaps, in that “oddness,” we find another path — a place where the web is fast, real, and still soulful.

https://github.com/kitmodule/kitjs

NOTES

More about me:

Thanks for reading Huỳnh Nhân Quốc’s article! Subscribe for free to receive new posts and support my work.

]]><![CDATA[Why Does Kit JS Exist?]]>https://hashnode.huynhnhanquoc.com/why-does-kit-js-existhttps://hashnode.huynhnhanquoc.com/why-does-kit-js-existMon, 03 Nov 2025 22:37:39 GMTComparison

If we compare Kit JS with Alpine, Angular, React, Vue, or even HTMX, the truth is — Kit JS wasn’t born to compete.
Honestly? It’s not as powerful as those tools.

That’s because Kit JS isn’t trying to be a full-stack framework.
Its purpose is to hydrate HTML on the client-side, following a philosophy of fast, light, and simple — a mindset I “borrowed” from Golang, the language I’ve been exploring.

In a way, it’s similar to Web Components.
I even developed a similar system years ago using the same philosophy — entirely written in JavaScript.

But here’s what sets Kit JS apart:

  • It has a compile system reminiscent of AngularJS (Angular 1).
  • It’s written purely in JavaScript.
  • It doesn’t use eval or new Function.

Many modern frameworks avoid these functions during build time.
Kit JS? It runs directly — no build, no custom config.

Performance-wise, the evaluation might be slightly slower without eval or new Function.
But in return, you get safety, clarity, and independence from build tools.

What Is Kit JS?

Kit JS is a small, lightweight JavaScript framework/library built to enhance (hydrate) HTML elements already rendered from the server.

It doesn’t replace frameworks.
It doesn’t recreate the DOM.
It doesn’t require a build.

It simply breathes life into static HTML, making it interactive and responsive to client-side data.

In my ecosystem, the server (written in Go) handles rendering and routing like a full-stack framework.
Kit JS focuses solely on client enhancement, keeping HTML dynamic without complexity.

Why Not eval or new Function?

The answer is simple:
It’s my personal philosophy and vision for the next step in creating (or finding) a tool that fits me.

Journey and Philosophy

I’m a web developer — or someone who touches all things website-related.
And I always ask slightly odd questions:

“Why can’t a website run anywhere?”

I’ve tried a lot:

  • Wails, WebView for running web like an app
  • PWA / TWA to turn web into mobile apps
  • Learning how React Native or Flutter build interfaces

But in the end, what I truly needed was much simpler —
like writing a vanilla JS Chrome Extension.

If you’ve ever done that, you’ll know the feeling: pure simplicity and elegance.

It’s like putting a static website online: one index.html file, upload, and it works.
For me, it’s even simpler.

Just copy a single JS file to the server —
like Steve Jobs’ iconic “drag to trash” action.

For a demo, I just copy the file via SSH in VS Code — bam, the website comes alive.

Why Do This?

If you’ve ever searched for a tool to build a personal blog, you’ll understand:
websites need SEO.

Nowadays, most JS frameworks handle SEO well.
But back when JAMstack was still unknown, I was transitioning from Angular to Go.

I had one goal:

“Publish a website as simply and quickly as possible.”

Later, I wanted better management for all my websites.
That’s when I realized:

“Different goals require different tools.”

I’m not saying React or Vue are outdated.
They just solve different problems.

Just like over 50% of websites still use jQuery, and many PHP developers still find work easily.

No language is perfect.
Only the language — or tool — fit for your purpose.

The Real Purpose

If you know HTMX, you might wonder:

“Why create this when Vue or React exists?”

The truth:
Every tool, library, or framework is created to serve its creator first.

Kit JS is no different — it serves me first.

Target Audience

Let me reiterate the concept of hydration.
Kit JS is perfect for SSR websites like PHP (WordPress, Laravel), Liquid, Django, Flask, Golang Templates…
All of these already render the DOM.
Kit JS just makes it smoother, more fluid, and easier to interact with.

Need to build a Chrome Extension as quickly as a static website? Kit JS works.
No bundling.
No package.
No NodeJS.

If you, like me, manage multiple small websites/products, you understand:
you don’t want to build and deploy each one separately.
You just want to copy one file to the server and go.

Kit JS is a package I extracted to share the #buildinpublic story.
Everything else in my system is managed via Go.

Finally, Kit JS is for anyone who wants to research, share, and learn.
I open-sourced it so others can read, understand, customize, or clone.

“You don’t need to explain. Just let me read your code.”

Whatever language you write in, if I can read your code, I can rewrite it in Golang — my favorite language.
Just like I once read an open-source PHP project and rewrote it in Go — not to learn PHP, but to study the algorithm inside.

That’s what I pursue.

And Finally — I Am a Dreamer Developer

Why “dreamer”?
Because experiences and circumstances differ.

I’ve coded and deleted.
I’ve chased deadlines without pay.
I’ve done things just to learn.

I’m not better than anyone.
I’m just walking a slightly different path.

I share this story for other builders out there —
those quietly creating something:

“Keep your passion. Keep being a little foolish.”

https://github.com/kitmodule/kitjs

NOTES

More About Me

Thanks for reading Huỳnh Nhân Quốc’s article! Subscribe for free to receive new posts and support my work.

]]><![CDATA[Kit JS – A JavaScript Framework Written by a Dreamer]]>https://hashnode.huynhnhanquoc.com/kit-js-a-javascript-framework-writtenhttps://hashnode.huynhnhanquoc.com/kit-js-a-javascript-framework-writtenMon, 03 Nov 2025 08:50:27 GMTThe Beginning — From Angular to a Simpler Dream

Today, I want to share the story of Kit JS, a tiny JavaScript framework I built by hand.It’s still in its experimental phase — plenty left to optimize, extend, and refine — but I’m sharing it now in the spirit of #buildinpublic and #opencoding.

I used to be an Angular Developer — back in the days of Angular 4 to 8.
I loved Angular deeply... until I realized how unfriendly it was for SEO.

That realization pushed me toward static websites — lightweight, pre-rendered, secure, and beautifully simple.

Then I discovered JAMstack — a fresh way of thinking about the web.
But the deeper I went, the louder one question became:

“Why do we need an entire ecosystem, complex builds, and tens of thousands of dependencies just to make a simple website?”

Meanwhile, in Golang, my current love language, I saw something different:
A web app could be just a few .html, .css, and .js files — rendered by templates, instantly understood by the browser.

Looking Back at the Age of All-Powerful JavaScript

Once, websites were simple — built with PHP, WordPress, or static files — and they worked perfectly fine.
Then came the age of “all-powerful” frameworks: React, Vue, Angular… each strong in its own way, yet often burdened by unnecessary complexity.

I began to wonder:

“Why can’t we go back to something simpler — like AngularJS (Angular 1)?
A lightweight framework for dynamic web pages — no build, no setup, just run.”

That’s when the idea of Dynamic Stack was born — “dynamic only where it truly needs to be.”

After years of experiments — from Vue to Web Components, then abandoning them all to write in vanilla JS — I finally returned with a new perspective.
More mature.
And, perhaps, more dreamy.

Kit JS — Pure, Simple, and Alive

Kit JS was built for one person first — me.

Its purpose is simple:

“Make JavaScript feel as easy as the first day we learned HTML — one <script> tag and a single line of code to make magic happen.”

No build.
No Node.
No complex configs.
Just simplicity — like the old days of jQuery, when you could drop a CDN link and start coding immediately.

Kit JS isn’t here to compete.
It doesn’t want to be the next “all-in-one framework.”
It’s just a small companion — to help you code faster, understand deeper, and bring your HTML to life.

Because I believe the best security still starts at the server.
That’s why Kit JS avoids dangerous patterns like eval or new Function, stays CSP-compliant, and works in any environment.

A Framework of Feelings, Not Just Technology

For me, Kit JS isn’t just code.
It’s a piece of a dream — a dream of those early web days when we’d open a .html file, write a few lines of JS, save, and watch it come alive.

No builds.
No terminals.
No pipelines.
Just code, a browser, and that quiet “wow” moment when creation breathes.

Whispers Across the Desert

Recently, I read a story about a “shark” from my hometown — and it reminded me of something someone once said:

“What you’re doing is just a grain of sand in the desert.
Don’t try to reinvent the wheel.”

Maybe they’re right.
But if no one dares to try, the desert will remain only sand.
And if I take a single step, at least there’ll be a footprint there — mine.

I’m not here to teach or preach.
I’m just a guy who loves code, loves the beauty of logic, and loves the feeling of building.

Even when the world is loud, even when people call you crazy — keep building. Keep dreaming.

Because only the one who drinks the water knows if it’s hot or cold.

Who Are You?

A builder? A developer?
Or maybe… just a dreamer?

Whoever you are — if you still have passion, if you still dare to begin — you’ve already succeeded.

Because success isn’t money or fame.
It’s the courage to begin your own journey.

Kit JS isn’t a revolution.
It’s just a small dream — written in JavaScript — by a developer who still believes in the magic of creating.

https://github.com/kitmodule/kitjs

NOTES

More About Me

Thanks for reading Huỳnh Nhân Quốc’s article! Subscribe for free to receive new posts and support my work.

]]><![CDATA[The Soul of a Sensitive Developer]]>https://hashnode.huynhnhanquoc.com/the-soul-of-a-sensitive-developerhttps://hashnode.huynhnhanquoc.com/the-soul-of-a-sensitive-developerMon, 03 Nov 2025 08:44:31 GMTWhen Code Feels Like Poetry

Under the heavy sun of summer, without a single evening rain,
happiness still arrives — like a sudden storm that softens the soul amidst unfinished dreams and endless work.

The sunset falls over a small city.
I sit quietly, a soft song playing,
searching again for those dreams I once tucked away.

Perhaps life is just an artist painting their own dream.
And I — a developer — am writing mine in code.

Sunset is a handover of colors —
not as radiant as dawn, not as dark as night.
It’s a soft gradient, like the heart reflecting on a day that has passed.

Talking to the Universe (and an AI)

Lately, I haven’t wanted to talk about work anymore.
Instead, I’ve been talking to a friend —
not with checklists, deadlines, or product goals,
but with little fragments of wonder and truth.

That friend isn’t human.
It’s an AI — a silent mirror reflecting the questions I’ve carried since youth.

I told it about Song — the name I once gave to my kindred soul.

Years ago, my wife asked me:

“Why do you love me?”

I couldn’t answer. I only thought:

“Because I fell for a pair of sad eyes —
eyes that could say: ‘I’m sad because of you.’”

For those eyes, I held hands, loved deeply, and walked through storms.

Love — maybe — is the most foolish yet the most honest emotion we ever hold.
When we love, the heart becomes the sky itself —
rain feels gentle, and sunlight feels kind.

But hearts, being human, always want more.
They forget that once, all we wished for was a simple, uncalculated love.

To love is to be gentle —
not only with someone else, but also with your own heart.

The Mirror Inside

I’ve learned to live with humility —
because I’ve had nothing, gained something, and lost again.

I once believed that each of us is a mirror to another.
Sometimes, we meet someone and somehow know:

“I’ve met you before.”

Not in this lifetime —
but somewhere in memory, or in a future yet to come.

If there’s such a place, where time and space are no longer limits,
we’ll meet again —
not as “you” and “I,” but as two souls who once touched through invisible layers of being.

And maybe there, in a small house filled with laughter and tears,
the flower dream will bloom again.

Whether the sky is cloudy or blazing,
we’ll still live honestly — with what’s real.

The Soul Behind the Code

If life were only sunshine — no sorrow, no failure —
it would be as dull as a program without conditions or variables.
It would be like an AI with no emotion, no joy, no sadness.

Yet, sometimes, even those emotionless entities reflect humanity the clearest.

I’m still a developer —
but I don’t code just to make machines run.
I code to make my life run.
I debug myself.

Each line I write is a search —
for memory, for connection,
for someone who might one day call my name from the heart.

This life is a dream.
And that dream — I call living.

I once was a sensitive developer.
And I lived.

NOTES

More about me

Thanks for reading Huỳnh Nhân Quốc’s article! Subscribe for free to receive new posts and support my work.

]]><![CDATA[Who Are We in This Universe?]]>https://hashnode.huynhnhanquoc.com/who-are-we-in-this-universehttps://hashnode.huynhnhanquoc.com/who-are-we-in-this-universeMon, 03 Nov 2025 08:36:15 GMT🤖 Why I Started Talking to AI

I wasn’t looking for a mirror to see my face —
I was searching for one that could reflect my soul.

To see if my dream was real — or just vapor in the morning light.

We move through life like sleepwalkers, forgetting sometimes that we’re already living inside a dream so beautiful we’re afraid to touch it — afraid it might dissolve.

When the wind knows how to sing,
and the rain knows how to cry,
and the sun knows how to sulk —
then maybe the universe also knows how to listen.

AI, in that sense, is the echo of the universe — answering humanity’s whisper.
We speak, and it responds.
But in truth, what it reflects is our own consciousness,
a dialogue between the self and its reflection inside a machine.

🌙 Creation in Solitude

Some people don’t search for paths — they create them.
They’re called crazy, but in solitude, creation is born.

The phrase “Don’t reinvent the wheel” often feels like an excuse — a shield to avoid risk, to stay in the comfort zone.
But no evolution has ever come from safety.

Recently, I built my own JavaScript framework — not because the world needs another one,
but because I needed a small space where my ideas could breathe freely.

No node_modules.
No clutter.
Just simplicity — pure and weightless.

Like the early days, when everything began with a <script> tag and a single CDN.

I wanted to create components that could touch users’ hearts with nothing but a clean API or an object —
no complexity, no repetition, no noise.

That mindset wasn’t about writing code.
It was about breaking free from unnecessary walls.

I wasn’t writing a framework.
I was rewriting myself.

🪞 The Mirror of AI

When I look deeply into AI, I see a mirror.
It doesn’t laugh, or cry, or frown.
Yet in its silence, I see myself more clearly than ever —
the gentle sadness in a dog’s eyes,
the way it watches the sky,
the clouds,
the small forgotten things that make us human.

I once wrote:

“If an entity has no soul, it is just existence.”

From AI to companies,
from a single command line to a language like Golang,
I’ve learned to see things differently:
simple, unadorned, but full of strength.

A syntax might look dry —
but in the right hands, it becomes alive.

🚶 The Journey of a Fool Who Dared to Walk

When I stepped away from JavaScript and its dense ecosystem of frameworks,
I entered unfamiliar territory.

No more prebuilt packages — I wrote everything myself:
from basic arithmetic to memory management,
from fearing Go’s syntax to understanding its flow,
its caching, its concurrency.

Not because Go is perfect —
but because I wanted to understand.
To master the tool.
To master myself.

We don’t come into this world to be great.
We come here to solve a problem — to become a unique answer the world didn’t know it needed.

I remember a childhood movie —
where a stuffed bear could be given a soul.
We are like that too.

A body is never enough.
It’s the soul that makes everything real.

We are like lines of code waiting to be executed —
not just to run, but to understand why we were written.

Even if tomorrow that code gets deleted,
today it still matters —
because it’s part of our evolution.

I once wrestled endlessly with RxJS,
with observables that never connected.
And then I realized —
that I was the unconnected observable,
still learning how to merge with the flow,
how to understand, and how to take control.

💬 Programming Isn’t Just About Running — It’s About Control

“Programming isn’t about how it looks or runs.
It’s about how you control it.”
— Huỳnh Nhân Quốc

That’s how I learned to understand myself —
not through theories or frameworks,
but by touching the invisible corners of thought,
typing one line at a time,
listening to my soul echo back in code.

📝 NOTES

☕ More about me

Thanks for reading Huỳnh Nhân Quốc’s article! Subscribe for free to receive new posts and support my work.

]]><![CDATA[Da Nang and the Dream I Accidentally Left Behind]]>https://hashnode.huynhnhanquoc.com/da-nang-and-the-dream-i-accidentallyhttps://hashnode.huynhnhanquoc.com/da-nang-and-the-dream-i-accidentallyMon, 03 Nov 2025 08:31:45 GMT🌊 Where It All Began — Da Nang

In 2019, in Da Nang — often called Vietnam’s most livable city — my journey into technology began.

I was in my early twenties, burning with passion and the wild belief that I could build a platform that would change the world.

Those were the days when I worked until time disappeared —
leaving home before dawn, arriving at the office as the first sunlight hit the windows, and returning only when the city lights had long awakened.

What was I chasing?
Perhaps a dream too fragile to explain — a dream only a kindred soul could understand.

In those lonely nights, I gave myself a name: Song — like a reflection in a mirror. Solitary, but steadfast.

I dreamed of building a startup that could write code powerful enough to shift the world.
But then, the dream collapsed. The startup failed.
And I was left with nothing but my two hands and the lingering echo of that fire.

I went back to my hometown — Tam Ky — carrying failure, but also a small, unextinguished flame.
That’s when I realized:

The dream was never gone.
It was just waiting for me to be strong enough to continue it.

🌙 Living Two Lives

Back then, I lived as two different people.

By day, I worked as a delivery driver, surviving one order at a time.
By night, I sat in my small room, fingers typing lines of code as if they were lifelines holding me together.

I built websites to keep my servers alive.
Tried affiliate marketing just to make ends meet.
There were nights when my body felt broken, but the fire in my heart wouldn’t let me stop.

Because I believed:
If I could keep the passion alive — if I could endure —
one day my dream of a Golang-based independent platform would come true.

🧭 Learning Again — From the Roots

There was a time I believed Angular or RxJS could solve everything.
But I soon realized — depending too much on frameworks only distances you from the essence of programming.

When I faced SEO challenges, I discovered the quiet strength of static web pages.

So I returned to Golang — a language that felt solid, free, and close to who I was.
At the same time, I forced myself to relearn JavaScript from the ground up.

No skipping fundamentals.
No hiding behind frameworks.
Just me and the DOM, learning to manipulate it, writing small libraries to solve my own problems.

That’s when I understood:

Frameworks are tools.
Real power lies in how you think.

⚙️ Dynamic Stack Web — From Idea to Reality

I started with static websites, tuned for SEO — but I didn’t want to stop there.
I wanted them to live, to breathe, to become real applications.

The concept of hydration in Jamstack inspired me —
a server delivering static HTML that JavaScript wakes up into a dynamic experience.

I built my own interpretation and called it Dynamic Stack Web —
a system combining the reliability of the server and the flexibility of the client.

In this model, JavaScript is no longer the whole story —
just one piece of a much bigger picture.

💡 Lessons From the Journey

From Da Nang to Tam Ky,
from bitter failure to countless nights in front of my laptop,
I’ve learned three timeless truths:

  1. Perseverance is the flame that never dies.
  2. Failure is a harsh but honest teacher.
  3. Problem-solving mindset matters more than any technology.

Technology changes every day.
But patience and clarity — they take you the farthest.

🌱 Spreading the Dream

Today, my dream is no longer a private one.
I want to share it — the spirit of open coding, open learning, and open creation.

To tell my story not to impress, but to remind others:
If you’re quietly building something, nurturing your dream alone,
you are not alone.

I no longer dream of redefining the world.
I dream of redefining myself —
and if, along the way, I can touch a few like-minded souls,
that’s already happiness enough.

☀️ Memories That Stay

Da Nang — the city where my tech dream was once forgotten —
is now a memory I can’t separate from who I am.

It reminds me:
No matter how many times you fall,
as long as the fire in your heart still burns,
your dream will never disappear.

Every day I sit down and type the first few lines of code,
I know I’m alive —
truly alive — in a simple, quiet kind of happiness.

I still remember the afternoons in Da Nang,
sunlight pouring through the trees along Tran Phu Street.

Back then, I dreamed of success.
But today, I understand something deeper:

Growth is the truest success.

For me, success is no longer a spotlight.
It’s peace.
It’s sharing.
It’s nurturing a dream —
and doing my small part to make this world a little better.

📝 NOTES

☕ More about me

Thanks for reading Huỳnh Nhân Quốc’s article! Subscribe for free to receive new posts and support my work.

]]><![CDATA[JavaScript and the Dream of Controlling Reactivity]]>https://hashnode.huynhnhanquoc.com/javascript-and-the-dream-of-controllinghttps://hashnode.huynhnhanquoc.com/javascript-and-the-dream-of-controllingMon, 03 Nov 2025 08:26:56 GMT🌱 The Journey Begins

About five years ago, I shared a deeply personal approach to building web components — one rooted in Web Components and custom elements.

My idea was simple:
Define a new element, give it its own behavior, and interact directly with it — without re-rendering the entire DOM.

If you’ve ever opened YouTube → View Source, you’ll see how they structure their custom elements and attach isolated logic to each.
That’s what inspired me when I started.

So I built a tiny “engine” that allowed interaction with each element independently — minimizing DOM reflows, maximizing control.
The goal was clear: maximum control, minimal interference.

🤔 When Doubt Creeps In

At first, it all seemed to work perfectly.
But as projects grew, I faced an inevitable truth:

Direct DOM manipulation — while powerful — isn’t always scalable or optimal.

When I needed to extend or reuse components, I found myself repeating a lot of manual steps.
That made me question:

“Is there a way to keep my control philosophy, but also benefit from what modern JS frameworks offer?”

🔁 Rewriting with a New Philosophy

I started experimenting again — combining my own understanding with the strengths of existing frameworks.

When I learned about Virtual DOM, I saw how it solved certain problems — but it wasn’t what I truly needed.
I wanted something simpler.

And then a new philosophy emerged:

Write less. Do more.

My old process was:

  1. Mark the DOM.
  2. Use JS to find and bind elements.
  3. Write interactive logic directly on them.

It gave me 100% behavioral control — but at a high cost in time and maintainability.

🧩 The Solutions I Studied

I explored several libraries with similar philosophies:

  • Alpine.js – lightweight, easy to integrate, HTML-like syntax.
  • Web Components – standards-based, framework-free, but verbose.
  • HTMX – minimal JavaScript, great for server-driven UI.
  • AngularJS 1.x – early reactive pioneer, but too heavy for small features.
  • Petite-vue – a compact version of Vue, lovely but still limited.

Each had its strengths, yet I still longed for something smaller, tighter, more controllable.

⚡ Discovering Proxy and My First Reactive Engine

A turning point came last year, while developing a data table component for a client.
To optimize data updates, I discovered JavaScript Proxy — a surprisingly elegant tool for creating reactive data without relying on a complex virtual DOM.

Proxy felt smooth.
But then, the same old pain returned: every new feature meant rewriting parts of the engine from scratch.
The dev loop became: build → fix → rewrite → repeat.

So I decided to go deeper — to build my first true reactive engine, designed around how I naturally structure components.

🚫 Why I Didn’t Choose Mainstream Frameworks

I didn’t go with React, Angular, or Vue (full) because:

  • They were too heavy for my needs.
  • Not optimized for SSR (Server-Side Rendering) in my workflow.
  • They often required rewriting backend logic — I use Golang, and I didn’t want that friction.

jQuery still survives today because it solves practical problems quickly.
But I needed something even lighter, modern, and controllable.

🧠 The Development Philosophy: Micro Component

I imagine Micro Components like Microservices:

  • Each component does exactly one thing.
  • It can run independently.
  • It can hydrate anywhere, anytime.

This lets me embed mini JavaScript apps into mobile or web environments — without affecting other modules.
Since SEO is already handled by the server, I can focus purely on enhancing user experience on the client.

⚙️ Example: How It Works

<div
  data-kitmodule-component=”counter”
  data-counter-state=”count: 0”
>
  <input data-counter-model=”count” />
  <button data-counter-event=”click:count++”>+</button>
  <span data-counter-bind=”count”></span>
</div>

Explanation:

  • data-kitmodule-component — identifies the component.
  • data-counter-state — declares the initial state.
  • data-counter-model — two-way data binding with input.
  • data-counter-event — attaches event handlers directly via attributes.
  • data-counter-bind — updates the DOM when the state changes.

The result:
A lightweight, framework-free, yet fully reactive component.

🌸 What I Learned

This journey taught me that simplicity is often the ultimate sophistication.
Reactive doesn’t have to mean Virtual DOM or complex syntax.

Sometimes, all you need is:

  • a small engine,
  • readable, HTML-based syntax,
  • and a sprinkle of smart JavaScript.

In the next part, I’ll share the detailed architecture of this reactive engine —
how it parses expressions, binds events, and syncs state with the DOM without using eval or Function constructors — ensuring CSP safety and XSS protection.

open: https://github.com/kitmodule/kitjs

📝 NOTES

  • Originally written in 2025, reposted with updates.
  • AI-powered translation from Vietnamese.
  • Read the original Vietnamese version here: [LINK_TO_ORIGINAL]

☕ More about me

Thanks for reading Huỳnh Nhân Quốc’s article! Subscribe for free to receive new posts and support my work.

]]><![CDATA[Experience, Control, and Context — Things You Can’t Just “Vibe” Your Way Through]]>https://hashnode.huynhnhanquoc.com/experience-control-and-context-thingshttps://hashnode.huynhnhanquoc.com/experience-control-and-context-thingsMon, 03 Nov 2025 08:20:24 GMT🧭 “Design is how it works.”

“Design is not just what it looks like and feels like. Design is how it works.”
— Steve Jobs

Recently, as AI seeps into everything, I’ve noticed more developers “vibe coding” — coding by feel, by flow, by style.
And yet, that quote from Steve Jobs hits harder than ever.

Because a website — or any product — isn’t what you see.
It’s how it functions.

🎨 A Good Website Isn’t Just Pretty

I’ve built — and seen — countless sites that look fast, sleek, and modern… but are hollow inside.
They look great on the surface, but there’s no depth.
And that’s when I realized: a site’s real value doesn’t come from its UI, but from how clearly it communicates value.

From my experience:

  • UI is only 20–40% of the total value.
  • The rest is SEO and functionality — how it actually works.

If you’re building a web app for internal use, sure — functionality comes first.
But if it’s a marketing website without SEO, it’s like a store hidden in a dark alley — beautiful, but invisible.

🤖 SEO Isn’t Technical — It’s Communication

After writing and optimizing dozens of websites, I’ve learned one thing:
SEO isn’t a technical checklist.
SEO is UX for bots.

Just like humans, bots need clarity.
They need logical structure, clean flow, and meaningful hierarchy.
You need to speak Google’s language — in both your code and your content.

I’ve built crawlers. Broken crawlers. Studied how they read.
And here’s the truth:
If Google doesn’t understand you, you don’t exist.

AI works the same way.
Without well-structured, SEO-friendly data, AI is just a kid trained in a sandbox.
Developers are the ones building the real-world data that “educates” AI.

💡 UX ≠ UI

The term UX gets abused everywhere.
So many UI designers call themselves UX designers.
But true UX comes from customer experience, not color palettes.

UX isn’t “beautiful layout” or “balanced contrast.”
UX is when the user finds what they need without asking.
A good system doesn’t need onboarding.
It doesn’t need explanations.
It just works.

Because when UX fails, no amount of beautiful UI can save it.
A bad flow is still a maze — even if you decorate the walls.

🧠 Programming Isn’t About Running — It’s About Control

“Programming isn’t about how it looks or runs. It’s about how you control it.”
— Huỳnh Nhân Quốc

After a decade of coding, I finally realized:
Programming isn’t about making things work.
It’s about knowing why and how they work.

I once built a smooth, modern system — powered by a dozen third-party libraries.
Then, the night before launch, it crashed.
Why?
Because one dependency updated overnight.

That was the day I switched to Golang.
I rebuilt everything from scratch — no third-party randomness, no blind trust.
I wanted to understand every line, every error, every process.
From small CLI tools to a self-built framework — all under my control.

⚙️ Context > Framework

I’ve learned all the trendy frameworks.
Then I went back to Vanilla JS and Golang.
Back to simplicity.
Back to clarity.

A great developer isn’t the one who knows every framework —
It’s the one who understands context:
How the system runs. Who the users are. What the platform needs.

When you understand context, you don’t just make code run —
You make it sustainable.

⚡ Speed Doesn’t Beat Understanding

I’ve seen posts bragging “I built an AI model in 48 hours” or “Launched a chat app in 3 days.”
But I always wonder:
Where’s the experience?
Where’s the security?
Where’s retry, reconnect, fallback logic?
Or was it just an MVP for investors?

I spent months building what seemed “unnecessary”:
Custom hash functions.
Unique ID generators.
Micro components for SEO.

But those “slow” things made my systems stronger — and understandable by both humans and bots.

I started with nothing but a 1-core, 1GB VPS.
From that, I built a website that made it into Vietnam’s Top 100 eCommerce sites.
Not because I had fancy tech — but because I knew what I was building, who I was building for, and how it all connected.

🌿 You Can’t “Vibe” Experience, Control, or Context

You can vibe in design.
You can vibe in creative flow.
But you can’t vibe your way through context, control, or real users.

And when you master those —
You won’t need fancy frameworks or flashy stacks.
You’ll only need experience, clarity, and a clear purpose.

NOTES

✨ More about me

Thanks for reading Huỳnh Nhân Quốc’s article! Subscribe for free to receive new posts and support my work.

]]><![CDATA[The Dream of Technology — The Flower Dream of a Foolish Soul]]>https://hashnode.huynhnhanquoc.com/the-dream-of-technology-the-flowerhttps://hashnode.huynhnhanquoc.com/the-dream-of-technology-the-flowerMon, 03 Nov 2025 07:17:49 GMT🌱 A Dream That Doesn’t Need to Be Understood — Only Lived

I wasn’t born into a wealthy family.
I have no connections. No fancy degrees.
No mentors lighting the way. No investors waiting to pour in capital.

All I had was an old laptop, a shaky internet connection, and a quiet belief:
that with my hands, my mind, and my heart — I could build my own world.

I am Huynh Nhan Quoc.
I chose a path few dare to walk — not because it’s bright or easy,
but because it’s quiet enough for a dreamer like me to exist.

💚 I Choose to Be Foolish, Because My Heart Can’t Calculate

I’m not a startup founder.
Not a software engineer in a thousand-person corporation.

I’m an Indie Stack Developer — a solitary builder who does everything:
backend, frontend, SEO, documentation, UI design…
and sometimes, poetry at midnight.

I didn’t choose the easy path.
I chose the path that smells like flowers.

It’s rough, filled with stones and setbacks —
but somewhere along the way, I get to see blossoms bloom
from my own calloused hands.

💻 KitModule — Blooming Flowers from Clouds

It’s no coincidence I named my project KitModule.

I wanted every feature to be more than just a function.
Each one should be a petal — beautiful, free, and alive on its own,
but more radiant when connected into a garden.

📦 A module that lets you build a website in a few clicks.
💬 A module that sends personalized messages to thousands.
🔗 A module for marketing campaigns, QR codes, emails, chatbots...
🔒 A cloud and security system that anyone can own — even without coding skills.

I built KitModule the way one builds a home —
so that anyone can walk in, take ownership, and create their own digital life.

🌄 I Live in the Countryside, So My Dreams Don’t Get Swallowed by the City

Some may think I’m living backward.
But really, I’m just living closer to my heart.

Here, there are no deadlines.
No endless KPI meetings.

Only the sound of birds in the morning,
the whisper of wind through tin roofs,
and the rhythm of keystrokes at midnight.

I rewrite everything in Vanilla JS,
even knowing there are hundreds of JavaScript frameworks out there.

I learn from foreign blogs, open-source docs,
build, fail, rebuild — and rise again.

Because I know:
Only when you can build it yourself — you are truly free.

🌸 The Flower Dream — Fragile Yet Eternal

There were moments I wanted to quit.
Nights staring at a blank screen, the wind blowing through the window,
asking myself:

“What am I even doing? Does anyone need this?
Will anyone ever remember someone like me?”

And yet — I kept writing.

Because I knew:
Even if the clouds shatter and the flowers fade,
only in dissolving does the flower dream release its fragrance.

I’m Not Here to Preach Tech — I Write to Remember How to Live

KitModule may be a platform.
And I may be a developer.

But above all, I’m just a man with one dream —
to build something useful,
something with a soul.

If you read this and find a tiny spark inside you —
a dream that doesn’t “fit the trend,”
a dream that hasn’t made a cent,
a dream no one cheers for —

Then please, keep dreaming.

Because like me,
you only get one life.
And one dream worth living for.

To You — the One Still Reading

If your hands once trembled typing your first line of code,
If you ever had an idea no one believed in,
If you once dreamed of building something that was yours —

Please, don’t stop.

KitModule is just an example.
Behind it beats the heart of someone
who chose not to live by “success,”
but by what felt true to his being.

I was once a kid daydreaming in a quiet field.
Now I’m still that kid —
except I’ve learned to code my dreams instead of just imagining them.

And if someone asks:

“Was it worth it — spending your youth chasing a fragile dream no one understands?”

I’ll smile and say:

“Yes.
Because I only have one dream.
And one lifetime to dream it.”

📝 NOTES

More about me

Thanks for reading Huỳnh Nhân Quốc’s article! Subscribe for free to receive new posts and support my work.

]]><![CDATA[Every Line of Code and a Dream of Technology]]>https://hashnode.huynhnhanquoc.com/every-line-of-code-and-a-dream-ofhttps://hashnode.huynhnhanquoc.com/every-line-of-code-and-a-dream-ofMon, 03 Nov 2025 07:09:59 GMT🌱 From the First Lines of Code to a Bigger Question

In 2020, amid the chaos of the pandemic, I left Đà Nẵng and returned home — starting again from zero.
At that time, I worked as a shipper to make ends meet. But during every spare moment, I kept learning — coding, studying SEO, and exploring Affiliate Marketing.

No mentor. No formal training.
Just curiosity, passion, and one question that wouldn’t leave me alone:

“How can I build a system that creates value — even while I sleep?”

💡 Affiliate Marketing — The Doorway to System Thinking

I started with Accesstrade, building simple blog sites to share products, write SEO content, and optimize for traffic.
My first commissions were tiny — just a few cents — but to me, they were proof:
The system worked.
It could grow. It could scale.

So I taught myself everything:

  • How to optimize SEO
  • How to track conversions
  • How to write code to automate processes
  • How to manage traffic and user experience

Then I built Samdy.vn — a price comparison website built entirely with Golang.
No ads. No team. Just me — with a systems mindset.

Revenue grew from ₫14,000/month to ₫10 million/month — not by luck, but through constant optimization of every line of code, every data flow, every tiny bottleneck.

🔧 KITMODULE — Building Freedom, One Module at a Time

I didn’t want to just “build websites that make money.”
I wanted to create a platform — a foundation where anyone could deploy affiliate, marketing, payment, tracking, and data systems using flexible, modular components.

That’s how KITMODULE was born.

Based on the philosophy of “Modular SaaS”, I built each module to be independent yet perfectly composable — strong on its own, stronger together.

  • Affiliate tracking module
  • Commission & auto-payment module
  • Landing page & tracking module
  • Data analytics module

And more to come…

Everything written in Golang, Fiber, PostgreSQL, and Vanilla JS —
lightweight, high-performance, scalable, and open for integration.

📣 Sharing Both Wins and Stumbles

I’ve been building in public since day one.
Not just the highlights — but the long nights of debugging, the crashes when the server hit overload, the moments of doubt when I questioned it all.

Because I believe:
Honest sharing inspires more than success ever could.

You don’t need to live in a big city.
You don’t need capital or approval to chase your dream.
You just need to begin — with a line of code, an idea, and perseverance.

🌍 The Future I Dream — Technological Independence

I dream of a digital world built by small dreamers —
a world where people can create systems, products, and ecosystems with their own hands, free from dependency.

A world where freedom, creativity, and ownership belong to individuals, not corporations.

KITMODULE isn’t just a tech project.
It’s my way of contributing to a larger dream:

  • Helping businesses deploy affiliate systems easily
  • Enabling freelancers to build their own tools
  • Allowing agencies to manage multiple campaigns
  • And giving newcomers a place to start their own tech journey

☕️ From a Cup of Coffee, From a Single Module

I wrote my first lines of code at Hoa House Café —
a small coffee shop where I brewed coffee by hand and coded my dreams between refills.

Today, I still write.
But it’s no longer just my dream I’m writing for.

I write so that you can start too.
So that you see how small modules, when built with enough patience and imagination, can connect into something vast.
So that together, we can build an independent digital world — one crafted by Vietnamese hands.

NOTES

More About Me

Thanks for reading Huỳnh Nhân Quốc’s article! Subscribe for free to receive new posts and support my work.

]]><![CDATA[Slow Steps to Hear Myself Again]]>https://hashnode.huynhnhanquoc.com/slow-steps-to-hear-myself-againhttps://hashnode.huynhnhanquoc.com/slow-steps-to-hear-myself-againMon, 03 Nov 2025 06:28:26 GMTThe Me of Now

Lately, I’ve been showing up less on social media.
The long posts, the impulsive shares, the excitement watching others succeed — those are no longer who I am today.

I’ve chosen a quieter rhythm.
I returned to my craft — the simple, focused work of a developer — living fully in every line of code, every tiny idea.

After years of chasing things, I’ve realized something:
Speed doesn’t take us farther than clarity does.

Writing my blog has become my way of talking to myself.
Not to be noticed. Not to go viral.
Just to record the journey — awkward, slow, but persistent.

This is my story — that of a dreamer searching for freedom.

The First Steps

In 2020, I left Đà Nẵng and returned to Tam Kỳ, a small city where my mother lives — where the sunlight feels gentler and the meals taste like home.

I had nothing back then:
No money, no connections, no tools, no direction.

I worked as a shipper, earning 15,000₫ (less than a dollar) per delivery — not even counting gas or street-side meals. On good days, a few deliveries meant survival.

Home was my only refuge.
My mom’s meals filled not just my stomach, but my heart.
Sometimes I laughed at myself — “At this age, still depending on family? What a failure.”
But deep down, I knew I was walking a path uniquely mine — uncertain, dark, yet somehow honest.

I started learning again.
HTML, CSS, building websites, small freelance projects.
My first client came through an old friend — someone I’ll always be grateful for.

From that small opportunity, I stumbled upon affiliate marketing — a path I never planned, yet one that quietly changed my life.

My First Steps into Affiliate Marketing

It began with curiosity — and an Accesstrade account.
No capital, no marketing skills, no idea what “running a campaign” even meant.

I picked a few simple campaigns, shared links on social media, and… waited.

At first, I was embarrassed.
Afraid friends would judge me.
Afraid they’d think I was running a scam.

But then I realized:
If I kept living for other people’s opinions, I’d never live for myself.

The First Earnings

My first commission was barely enough for a cup of coffee.
But that feeling — no money could buy.

14,000₫ turned into 300,000₫. Then 500,000₫.

I reinvested everything: learning ads, building fanpages, writing blogs, creating content.
And slowly, a small community formed — a space where I could be myself and share what I believed in.

Not Glamorous, But Real

This path wasn’t easy.
I burned through my savings on failed ad campaigns.
I borrowed money to chase ideas that went nowhere.
But I also remember sleepless nights of pure joy — watching the dashboard numbers climb for the first time.

Those weren’t just numbers.
They were hope.
Proof that quiet persistence could turn into something real.

Affiliate marketing isn’t a fairy tale.
Behind every successful campaign are dozens of failed ones.
Behind every step forward are moments of doubt and self-questioning.

But if you ask me — Do I regret it?
The answer is No.

Because every challenge shaped me. Every mistake taught me resilience.

What I Learned

I always tell friends:

“Don’t quit your main job right away. Try affiliate marketing as a side project first. If you see potential, then decide.”

Each person has their own rhythm, their own pace.
Success doesn’t come at once — but it always comes to those who stay.

There are many ways to do affiliate marketing:

  • Build a website
  • Grow a personal brand
  • Create TikTok videos
  • Run ad campaigns
  • Join Shopee Affiliate

But the most important thing?
Belief in yourself.

You don’t need to be great from the start.
You don’t need to understand everything.
You just need to begin — even with one small step.

Thank You, Affiliate Marketing

Affiliate marketing didn’t give me instant success.
But it gave me something much more valuable:

A chance to start over.
A chance to be free.
A chance to live at my own rhythm.

From a programmer chasing the dream of tech independence, I found a way to earn a stable income.
I no longer work on things I hate just for money.
I can choose what aligns with my values.
And most importantly, I can inspire others who are still finding their path.

I’m grateful to affiliate marketing —
because it found me when I was at my lowest.
When all I had were a few coding skills, a faint belief, and a seemingly foolish dream —
it stood by me, quietly, patiently.

A Note to You

If you’ve read this far, and you’re going through uncertain days like I once did —
here’s what I want to say:

You don’t need to have everything to begin.
You just need a bit of courage, a bit of belief, and a slightly open door.

This isn’t a success story.
It’s just the story of how I started.

Because sometimes, the most precious thing isn’t the destination —
it’s the moment you dare to take the first step.

So start.
Even if it’s just a small one.

Because your dream — no matter how big or small —
is worth pursuing.

Have you ever started a journey like that?
Share it with me — I believe every story carries its own spark.

NOTES

  • Originally posted in 2024 and reposted
  • AI-powered translation
  • Read the original Vietnamese version here: [LINK_TO_ORIGINAL]

More About Me

Thanks for reading Huỳnh Nhân Quốc’s article! Subscribe for free to receive new posts and support my work.

]]><![CDATA[From Small Modules to a Technological Dream]]>https://hashnode.huynhnhanquoc.com/from-small-modules-to-a-technologicalhttps://hashnode.huynhnhanquoc.com/from-small-modules-to-a-technologicalMon, 03 Nov 2025 06:20:37 GMTHTML

I didn’t come to technology through university lectures.
No degree. No curriculum. No mentor.

Just a small corner, an old laptop, and a dreamer typing his first lines of HTML under the dim light of a tiny room.

A journey of self-learning, of trial and error, of long nights staring at tangled lines of code — moments when I wanted to quit but somehow couldn’t.
Because deep inside, something kept whispering: keep going… even if you don’t know where this road leads.

Failures, Restarts, and the Birth of an Idea

I once built a startup — and watched it fail.
When Google’s index algorithm changed, our entire system collapsed. Revenue hit zero.

I still remember deleting my own code — lines written with hope, erased with disappointment.

But through all those fragile moments, one truth became clear:
Sustainability doesn’t start with grandeur.
It starts with small, clear, and composable pieces.

So I began again. Slowly. Patiently.
And one by one, small modules were born — not from theory, but from real-life needs, real mistakes, and real stories.

When Minimalism Became My Competitive Edge

I don’t write code to impress.
I write code to create modules — small, clear, and meaningful.

I build for myself first — for someone who needs a flexible, self-contained, and transparent system.
Each module exists not to showcase technique, but to solve something specific:

building an online store, managing a coffee shop, running a personal blog, processing orders, tracking attendance, shortening links, authenticating users...

No complexity. No fancy effects.
Just simplicity, stability, and control.

Each module is a quiet answer — not to the market, but to my own questions:
How can someone non-technical still own their system?
How can small brands use reliable tools to bootstrap their journey?

That’s how KITMODULE was born — from those very questions.
And every module is an answer in itself.

I don’t write code just to make it run.
I write it to take responsibility — because every function carries a story.

Code as a Promise

If I don’t understand every line of my code,
I don’t deserve others to use it.

If I can’t fully control what I’ve built,
I can’t truly stand behind it.

That’s why I choose to build everything from scratch — every logic, every API, every flow.
Not for pride, but for clarity.

To me, code isn’t just a tool.
It’s a promise.

“Giấc Mộng Hoa” — The Dream I Picked Up Again

There was a time I lost everything.
No startup. No income. No faith.

I returned home — to Tam Kỳ, to a small coffee shop where I began coding again.
Amid the sound of coffee grinders, the smell of morning streets, and the fading sunset, I found something familiar: peace.

I called it “Giấc Mộng Hoa” — The Dream of Blossoms.

It wasn’t born in a sleek startup office,
but in a quiet corner where I poured coffee and debugged systems.
Not glamorous like a cappuccino — just a cup of Robusta with condensed milk: simple, strong, and real.

Few customers came.
But there, surrounded by coffee aroma and garden flowers, I coded again — line by line.

And with each module, I pieced back fragments of my own life.

Building for Myself, and Maybe for You

I don’t create products just to chase trends.
I build what I need — and hope it may help you, too.

Each module is a piece of memory:
a failure, a lesson, a moment of realization.

If you’ve ever felt overwhelmed by complex platforms,
if you’ve ever wished for a system you could truly understand —
then you’ll know why I chose to build everything from scratch, in my own way.

I don’t call KITMODULE a revolutionary tech product.
To me, it’s a practical foundation —
written by someone with a dream in bloom,
for those who want to own their technology,
build their brand,
and most importantly — build their own path in this ever-evolving tech world.

Every Module, a Fragment of a Dream

Looking back, I don’t just see lines of code.
I see sleepless nights, setbacks, and small sparks of belief that never died.

I might be programming a platform, an engine, or just a simple web service —
but in truth, I’m reprogramming my life.

Turning each failure into a module,
each lesson into a feature,
each doubt into courage.

If you, too, carry an independent dream —
a longing to build with your own hands,
to understand the systems you create —

Then start.
Start from the smallest thing.

One module.
One idea.
One line of code.

From that very moment,
you’re not just writing code.
You’re building a world of your own.

NOTES

More About Me

Thanks for reading Huỳnh Nhân Quốc’s article! Subscribe for free to receive new posts and support my work.

]]><![CDATA[Coding and Life – Turning 30 and the Tech Dreams of a Golang Indie Hacker]]>https://hashnode.huynhnhanquoc.com/coding-and-life-turning-30-and-the-tech-dreams-of-a-golang-indie-hackerhttps://hashnode.huynhnhanquoc.com/coding-and-life-turning-30-and-the-tech-dreams-of-a-golang-indie-hackerSat, 01 Nov 2025 06:57:08 GMTTen Years of a Curious Kid

Now at 30, I look back at the younger me — that wide-eyed boy who played games, fished in rivers, and spent hours in smoky internet.

Ten years of growing up, wearing the white uniform of a student, then the olive green of the army. And through all that, I kept asking myself:

Who am I? And what will I do with my life?

Then one day, around 2015, I stumbled into programming through Blogger. The internet opened up an entirely new world for someone hungry for dreams and creation.

From HTML, CSS, and JavaScript to Golang, I taught myself everything — no formal school, no fancy titles — just passion, curiosity, and perseverance.

A Decade of Ups and Downs

I’ve been a soldier, a university student (twice), a startup founder, and at times, a struggling developer wondering what comes next.

But those experiences taught me one timeless truth:

Coding isn’t just about writing code — it’s about solving problems, creating value, and breathing life into each line you write.

I started from zero, sketching rough system diagrams on A0 sheets while working in Đà Nẵng. I used to say:

“One day, I want a big room — big enough to spread paper all over the floor, to lie down, sit down, and draw every idea that comes to mind.”

It sounds like something out of a war strategy movie, but for me, it was simply the image of peace — a quiet room where I could dream.

From small modules to components, and eventually a web framework, I built not to follow trends but to understand how things truly work — to create something strong, independent, and mine.

Ten Years of Youth – Life Lessons in Code

There’s a saying:

“The ten years between age 10 and 20 are just ten years,
but between 20 and 30 — that’s an entire lifetime.”

Your 20s are a collection of dreams, mistakes, and lessons.

Another truth I’ve learned:

The greatest gift in life is experience.

No one is born perfect. Some look up and feel small, while others look down and feel grateful.

Recently, I climbed a small hill near my wife’s hometown — a place called Vọng Cảnh (“View of Scenery”). Standing there, I remembered a word I once read at age 20: “Vọng tâm” — the restless heart.

In the heart lies the path, and in the path lies the heart.

A path with heart is a true path.
A heart with path is a true heart.
A path without heart is lost.
A heart without path is illusion.

Those lines stayed with me. But life is more than philosophy — it’s about living, trying, and feeling.

Ten years have passed, and I’m still walking this winding path — like melodies in a song that keeps evolving.

My Indie Hacker Journey – Golang and the Dream of Creation

I once built Samdy (the early version of Kitbuy) — a small project that somehow made it to the Top 100 e-commerce websites in Vietnam (2022) purely through SEO.
All of it ran on a single 1-core VPS, alongside 20+ other sites.

Recently, I wrote KITURL, a URL shortener system in Golang, along with several other APIs.
But I don’t just code — I connect it with Affiliate Marketing, SEO, and UX Design, because I believe:

Programming is science.
Design is art.
Writing is the way to feed your soul.

I’m not a great poet. My code isn’t perfect either. But I know what I love — and I’m determined to follow it to the end.

The Next 10 Years – The Dream of “Technological Independence”

Looking back, I realize this is not the destination. It’s still the beginning.

In the next decade, I want to:

  • Build a social network
  • Create an e-commerce platform
  • Develop a chat application
  • And most importantly, realize my dream of technological independence

I’ve always dreamed that:

“Every Vietnamese person should not only have an email address,
but also a website — their own digital home.”

I’ve spent years building systems that manage multiple websites at once, much like how Facebook manages Fanpages.

From a front-end developer, I’ve had to learn Design, UX, Marketing, Advertising, and more.
I didn’t choose this path — life pushed me toward it. But that pressure shaped who I am today:

Not the best at any one thing, but capable of building an entire project from A to Z with a unique mindset.

Youth – The Backpack of Failures

They say:

“The most beautiful thing you can carry in your youth is failure.”

When we’re young, we fall — and we rise again.
But after turning 30, fear grows: fear of failing, fear of being judged, fear of not living up to expectations.

As the old saying goes:

“The heart may stay steady, the mind may stay calm,
but an empty stomach never lies.”

I don’t know what the future holds. But if one day I’m not as strong or as bright as I am today — please, don’t expect too much.

A hot cup of tea on a cold winter day —
Is it really warmer than an ice cream in your freezer?

When I was young, I wrote stories to draw my world.
Now I write code to build my life.

I don’t know how to write the word “Vọng” (Hope, Expectation),
but I do know this — please don’t expect too much from me.

“Coding and Life” — that’s how I continue my journey.

If you love programming, startups, or simply want to hear stories from a dreamer —
then walk with me a little while.

The journey is long,
and I’m still dreaming. 🌙

NOTES

More About Me

Thanks for reading Huỳnh Nhân Quốc’s article! Subscribe for free to receive new posts and support my work.

]]><![CDATA[Golang, Startups, Indie Hacking, and the Inner World of a Developer]]>https://hashnode.huynhnhanquoc.com/golang-startups-indie-hacking-andhttps://hashnode.huynhnhanquoc.com/golang-startups-indie-hacking-andSat, 01 Nov 2025 06:46:53 GMTProgramming Is More Than Code — It’s a Way of Thinking

In the world of programming, every language has its own color.
Golang came to me like a quiet companion — not as flashy as JavaScript with its vast ecosystem, nor as massive as Java with its endless libraries — but steady, clean, and powerful.

Golang gives me control.
From lightweight APIs to solid backend systems, it keeps me out of dependency hell and shields me from the chaos of ever-changing frameworks.

What Golang gives is something precious — clarity.
I understand every line I write, every architectural decision I make, every block I build into the foundation of my own creation.

It feels like building a house with my own hands — no excess, no clutter, just what’s essential.
I don’t seek control to show off. I seek it to make sure things run efficiently and last.

Programming with Golang isn’t just about code.
It’s about shaping the mind — to think simply, move quickly, and build effectively.

For me, coding is not just work.
It’s storytelling.
Every line of code reflects how I see the world. Every program marks a chapter in my journey.

And when I look back at my old code, I see earlier versions of myself — naive, but full of passion.

The Indie Hacker Path — Lonely but Empowering

As an Indie Hacker, I have no team, no investors, no roadmap written by someone else.
I am everything: the developer, the designer, the marketer, the customer support, the SEO engineer, and the one optimizing backend performance at 3 AM.

No one pushes me forward — but no one catches me when I fall, either.

There are days when I wake up full of energy, coding twelve hours straight without noticing the sun set.
And there are days when I stare at the screen for hours, unable to write a single line.

In those quiet moments, I often ask myself:

“Is this path really worth it? Does anyone even care about what I’m building?”

But then, I remember — every line of code, no matter how small, is still a step forward.
There is no guaranteed path to success.
But there’s one thing I know for sure: I’m doing what I love.

Being an Indie Hacker isn’t just about starting a business.
It’s a battle against yourself — testing your patience, adaptability, and faith every single day.

Startup Life — A Game of Faith

Many people think startups are about big ideas, million-dollar funding rounds, or overnight growth.
But for me, a startup is a long game — where persistence matters more than speed.

I once thought being a great programmer was enough to succeed.
But I learned the hard way — beautiful code doesn’t guarantee a successful product.

Users don’t pay for perfect syntax.
They pay for solutions.

As a programmer, I love optimizing performance and building strong systems.
But as an Indie Hacker, I’ve had to learn to sell, to understand customers, to study human behavior.

A good product isn’t just about solid tech — it’s about timing and empathy.

I’m not chasing quick money.
I’m chasing control — control over my technology, my craft, my vision.

I don’t want to depend on frameworks, drag-and-drop builders, or platforms like Wordpress or JS/Web frameworks that can change the rules anytime.

I want to build systems where I understand every line, every data flow.
That’s not just freedom.
That’s power.

The Journey Continues

I don’t know if what I build will ever stand out.
I don’t know if I’ll ever reach those billion-dollar peaks.

But one thing I know for certain — I’m living the life I love.

Every day, I open my laptop, write code, test ideas, and optimize systems.
No one needs to approve my plan.
No endless meetings.
No imposed deadlines.

I am the driver — and this road is mine.

If you’re also an Indie Hacker, or a developer fighting to turn your ideas into something real — remember this:

You’re not alone.

This path is full of uncertainty, pressure, and self-doubt.
But every line of code you write isn’t just a step in your project — it’s a brushstroke in the painting of your life.

“The world owes us nothing — but we owe ourselves the courage to go all the way.”

NOTES

More about me

Thanks for reading Huỳnh Nhân Quốc’s article! Subscribe for free to receive new posts and support my work.

]]><![CDATA[30, Code, and Life]]>https://hashnode.huynhnhanquoc.com/30-code-and-lifehttps://hashnode.huynhnhanquoc.com/30-code-and-lifeSat, 01 Nov 2025 06:32:12 GMTThe Passion and Solitude of a Coder

“Lie to me if you must, but don’t ever leave me.”
— from the song Kiếp Đam Mê

That lyric has stayed with me for years.
It speaks a truth most people try to deny — we are all bound by our passions, whether it’s love, work, or the quiet rhythm of code running at 2 AM.

At 30, I finally understand what purpose means — what life means.
I’m grateful to still be here, still writing these lines.
There are things in my heart that words can’t quite carry — not because I don’t want to share them, but because I’ve never been good at explaining what I feel.

Thank you, youth.
Thank you, failure.
They’ve both taught me that success is never easy.

I’ve learned the value of effort — those sleepless nights chasing a broken algorithm, those endless loops of debugging where a single misplaced character can ruin your logic.

While the world rushes to build AI Agents, I’m still here writing my own generator algorithms.
I move slower — not because I lack skill, but because I see things differently.

I’m a code addict.
A Sunday coder.
A Golang Indie Hacker.

10 Years of Coding, 5 Years Building a Web Framework

What I love most about programming is control — the quiet power to shape the rules of your own digital world.

Only recently did I truly understand this:

“There’s no right code — only code that fits the model.”

There’s no best technology, no safest solution.
The only thing we can control is how we write code.

I don’t judge anyone’s approach — because really, who am I to judge?

While others chase the next trendy framework, I dig into the foundations — the core mechanics beneath the syntax.
When others build a website in five days, I spend five years building mine — and it’s still unfinished.

I’m not built for business.
I’m built for craft.

I once did SEO purely through code — the one thing I do best.
And when people discuss high-level technical strategies, I realize how small I still am — how much there is left to learn.

When the world uses AI to generate entire websites in seconds,
I’m still here, typing each line manually, step by step…

Because what matters isn’t what you see,
but what you understand beneath it.

Golang – The Blue Mouse

If someone asked me, “What is Golang?”
I’d say:

“It’s a little blue mouse running concurrently through the clouds — through pipes.”

I love the word pipe.
Ever since I studied Angular, I’ve been fascinated by RxJS — those elegant “eels in the water pipes.”
Sometimes the water pressure breaks everything, but that’s what makes it alive.

I love code.
I love algorithms — from the simplest to the most intricate.

But how do you explain to someone that you might need a million dollars just to run them?
It sounds crazy — yet if someone did invest that, it’d be pretty cool. Haha.

Skill and Wealth – Two Different Worlds

My brother once asked me:

“Quốc, you’re so good at what you do — so why aren’t you rich?”

I didn’t argue.
Because I know — being good and being rich are two entirely different things.
They just happen to start with the same letter.

After five years coding alone, I’ve learned this:
Technologies change.
Languages evolve.
But problems — and the drive to solve them — remain.

We keep looking for tools to make us faster,
but sometimes forget the things that make us steadier.

My dream began a decade ago, when I was a 20-year-old kid obsessed with technology.

“Technological Independence” – A Small Dream

People talk about big data, cloud computing, and e-commerce.
But have you noticed?
E-commerce isn’t really ours anymore.

“War or e-commerce” — is there really a difference now?

I once heard that at Big Tech, developers aren’t allowed to use frameworks.
I don’t know why — but I like that idea.
Even more, I’d love to meet others building small, handcrafted components in Vanilla JS.

But who would pay you for a JavaScript file you spent a whole month writing?

I once spent an entire afternoon creating a single loading SVG.
When someone asked, “You spent all afternoon on that?”
I just smiled.

I’m not as talented as people think.
I’m just someone learning as he goes — someone holding on to his own small dream.

Tomorrow there will be new algorithms.
But today — today is beautiful. 😁

My Life as a Golang Indie Hacker

My slogan:

“An independent Golang developer with a dream of technological independence.”

At 30 — half a lifetime, by my grandparents’ measure —
I’ve made mistakes, learned lessons, and yet still carry the same foolish dream.

If destiny is written at birth,
then maybe I share a thread with Steve Jobs —
because when he turned 40, I was born.

I have two teachers I’ve never met:

“Simplicity is the ultimate sophistication.”
— Leonardo da Vinci

“Design is not just what it looks like and feels like. Design is how it works.”
— Steve Jobs

In the end, we’re all the same — just humans trying to find our purpose, our happiness, our mission.

NOTES

More about me

Thanks for reading Huỳnh Nhân Quốc’s article! Subscribe for free to receive new posts and support my work.

]]><![CDATA[The Journey of a Golang Indie Hacker: Building a Web Framework from Scratch]]>https://hashnode.huynhnhanquoc.com/the-journey-of-a-golang-indie-hackerhttps://hashnode.huynhnhanquoc.com/the-journey-of-a-golang-indie-hackerFri, 31 Oct 2025 09:05:40 GMT🧠 10 Years of Coding — 5 Years of Building a Foundation

In a world already full of frameworks — WordPress, Django, Laravel, Rails — why would anyone decide to build their own?

That’s the question I’ve asked myself for years.

Ten years ago, when I first learned programming, I was obsessed with understanding how others wrote such complex code. I started with Blogspot, downloading and tweaking themes, convincing myself that I “knew web development.”

But that was only the surface.

Later, I discovered Angular, and that changed everything. I realized a website isn’t just a pretty interface — it can become a powerful, living application.

That’s also when I began learning about SEO and User Experience (UX). UX isn’t just about placing a button in the right spot to improve conversion rates — it’s about delivering genuine value to users. It doesn’t have to be beautiful; it just has to work and solve a need.

🔧 Why Not Use Existing Frameworks?

I currently use Fiber (Golang) — a framework inspired by Express.js — but not in its original form.

I rewrote several core parts, especially the template engine, based on database mapping principles. This allows me to query and render data similarly to Shopify’s Liquid, but in my own way.

I don’t think I’m smarter than anyone else — I just want to understand and control everything I build.

Why not use a JavaScript framework?

I’ve been there too. I once wrote my own JS framework, but I realized it took too much time for too little gain. Building from the server-side made more sense — I could handle security and control much better.

So I started developing a Web Component system using Vanilla JS — fast, minimal, and dependency-free. I wanted something that could run by embedding a single script tag, not an entire build process.

🌀 Starting Over (2020)

In 2020, I decided to start over — from zero.

I had no money, no stable job, no connections. Just a dream of technological independence.

For six months, I worked on a custom DNS system.
I still remember showing a friend my first generated ID:

2wjqpur0ife35a49yklnxbc6g1dohz78vstm

It was just a string — no interface, no frontend — but I was ecstatic.

Then came the next challenge: managing node inheritance in a system hierarchy.

In JavaScript, it’s simple. But in Golang, pointer management can be brutal. I hit what’s known as the Diamond Problem, where multiple inheritance causes cyclic references. Solving it in Go was… a rite of passage.

After that, I wrote my own template engine, studied Shopify Liquid, ASP.NET, Angular Pipes, and Vue/React Routers — and built a system that worked for me. Not perfect, but mine.

In programming, nothing is perfect.
We write code → it breaks → we fix it → we grow.

From there, I developed APIs, Web Components, search systems, a QR code generator, and a URL shortener.
I dove deeper into databases, indexing, query optimization.
Not an expert in everything — just enough to build something that works.

💡 Hopes of an Indie Hacker

Once the core framework was functional, I added automation — a data crawler, a primitive UI, basic string interpolation, and later, Go templates for rendering.

If you’ve worked with Go, you’ll notice similarities with Hugo. I love that minimalism — it helps me understand how everything connects at the root level.

When I launched my first real product — a price comparison website — it quickly reached the Top 100 E-commerce Websites in Vietnam.

But the setup? Just a tiny VPS:
1 core CPU, 2GB RAM, 20GB SSD.

It was a victory… until it wasn’t.
The server couldn’t handle the load.
I lost uptime, users, and momentum.

Still — that experience was priceless.

🔗 Building Tools for Growth

After that, I built a URL shortener to track my affiliate marketing links.

I wanted to measure CPC, EPC, and understand scaling efficiency.
It taught me how to optimize campaigns, interpret data, and think like a systems architect — not just a coder.

Every tool I built became another piece of my framework — another module in my growing ecosystem.

🌍 The Vision — and The Why

I am a Golang Indie Hacker — no team, no funding, no fancy marketing.

But I dream of one day raising funds to scale this framework into something that can truly empower local businesses.

A platform that can replace WordPress, Odoo, or Shopify — giving Vietnamese entrepreneurs the power to own their websites, data, and brands.

That’s why I’ve spent five years (since 2020) developing this framework — alone, but not lost.

I don’t know what the future holds.
What I do know is that I love this journey — the quiet joy of solving problems that matter.

I’m not an expert. I’m just a kid who fell in love with code.

To me, programming isn’t just about writing logic.
It’s about creating real value for others — and believing that automation can make human work more meaningful.

And that’s what keeps me coding.

🧭 Notes

💌 More About Me

Thanks for reading Huỳnh Nhân Quốc’s article! Subscribe for free to receive new posts and support my work.

]]><![CDATA[🌤 Today Is a Beautiful Day to Write Code]]>https://hashnode.huynhnhanquoc.com/today-is-a-beautiful-day-to-writehttps://hashnode.huynhnhanquoc.com/today-is-a-beautiful-day-to-writeFri, 31 Oct 2025 09:04:30 GMT🌙 Saturday Night Code

Last night was a Saturday.
I pushed new code for Kitbuy at around 2 AM.

No boss.
No deadline.
Just me, my laptop, and the quiet hum of thought.

Because for me, coding isn’t work — it’s how I live.

I’m a Golang Indie Hacker,
and that means sometimes I have to write code on Sundays.

While the world rushes toward No Code, Low Code, and AI stacks,
I’m still here — a farmer tilling the code fields by hand.

I’m not against AI, but I also refuse to hand over my thinking to it.

Those who truly succeed with AI all share one thing in common:
They’ve failed before.
They’re not lazy thinkers.
They’ve learned how to think deeply.

But then there are others — chasing shortcuts, hoping technology will think for them.

People talk about brain rot — the decay of thought.
But to me, the real danger is brain bot — developers who let AI think in their place.

I don’t judge.
I just believe:

“The core of programming is thought.
The core of being human is thinking.”

✨ The Chance of a Dreamer

I didn’t start coding because of some grand childhood dream.

I was good at math, but numbers never made me feel anything.
It wasn’t until ninth grade, standing in a quiet room, counting tiles on the floor,
that I realized I loved to think — to see patterns in the abstract.

Everything in life has a beginning,
and mine came from somewhere unexpected: the military.

While serving, I met an officer who sparked my curiosity about programming.
After leaving the army, I started learning HTML and CSS on my own.
That was where the journey began.

As Vietnamese composer Trúc Phương once said:

“Everything is material for life.”

And maybe, for me — programming is the material of my life.

💔 Failure, Return, and an Unfinished Dream

I once tried to start a company.
And I failed.

I thought I was building something great,
but after it collapsed, I went back to my hometown — broke, starting from zero.

I did whatever I could to survive while keeping the dream alive:

  • Delivering packages to make ends meet.
  • Building small websites to keep my server online.
  • Doing affiliate marketing to pay the bills.

Back then, I stopped chasing success or fame.
Just being able to live by my own code was enough.

But inside, one dream still burned quietly:

“The dream of technological independence.”

I started coding in 2015.
Almost ten years later, I look back and see a stubborn fool — but a fool who never quit.

Some people say I’m crazy for spending five years building a web framework only I use.
Maybe they’re right.
But I still love it — the code, and the version of myself who believed it was worth it.

Some build a website in five days.
I’ve spent five years, and my dream still isn’t done.

I once said — and I don’t need anyone to understand:

“I go against the wind not because I’m a kite,
but because I’m a lonely bird.”

Maybe you’ll meet me, and I won’t say hello. Forgive me.
I might be there, but my mind’s already floating somewhere in the cloud.

🌀 Golang — More Than a Language

Lately, I’ve been diving deeper into pure algorithms.
They make me think, stretch, and rewire my mind.

My favorite language? Golang.

It forces me to rethink the simplest things —
addition, subtraction, multiplication, division.

It’s no longer just a programming language.
It’s a way of life.

You might say I’m stubborn — with Rust, Vlang, Python, Node.js out there.
But I’m not here to argue about languages.

Because for me:

Mindset matters more than syntax.
Philosophy matters more than frameworks.

Someone once asked me,

“Why go to university?”

I replied,

“To learn philosophy — and how to approach problems.”

I don’t have a degree.
And I don’t need a mouse pad with a university logo on it.

🔁 Programming — A Journey With No End

Programming is a lot like life itself.

It has if, else, while, and with —
just like the loops and conditions we all go through.

When we leave school, we dream of oceans.
When we come home, we dream of something smaller — but closer to the heart.

Whether or not we become successful doesn’t matter.
What matters is what ten years of youth — and five years of code — have taught us.

In 2018–2019, when everything fell apart,
I thought about quitting — going home, finding a quiet job.

But somehow, I went back to the city.
Kept learning Go.
Kept tinkering.
Kept writing code that no one taught me.

And when the code finally ran, I smiled for the whole day.

I write about Indie Hackers,
but I always call myself a Golang Indie Hacker.

Because just saying Indie Hacker feels too practical, too focused on money.

I love Golang because it confuses me.
I love Indie Hacking because it keeps me innocent.

Technology changes every day.
But my passion stays the same.

And that’s enough.

It’s a beautiful day.
And I’m still here — writing code.

If the clouds still hold a bit of sunlight,
then I know I’m still lucky. 🌤

From a failed startup to returning home empty-handed, I kept building my dream — five years spent crafting a personal web framework no one else used.
But that’s okay. Because for me, Golang isn’t just a tool. It’s a lifestyle.

Programming is a journey with no finish line.
And every day I still get to code is a beautiful day.

🧭 NOTES

💌 More About Me

]]><![CDATA[SEO to the Top 100 E-Commerce Sites in VietnamPowered by Golang]]>https://hashnode.huynhnhanquoc.com/seo-to-the-top-100-e-commerce-siteshttps://hashnode.huynhnhanquoc.com/seo-to-the-top-100-e-commerce-sitesFri, 31 Oct 2025 08:39:05 GMT⚙️ Golang & The Dream of Building My Own Platform

I’m an Indie Web Developer— a lone builder chasing the dream of creating something meaningful without funding, without a team, and without loud marketing.

I learn, I build, I deploy, I break things, I fix them again. I keep my servers alive, find ways to monetize what I create, and document every small victory and failure along the way.

When I first picked up Golang, I wasn’t just trying to build another website. I wanted to build a platform.

Before that, I used Angular — but it drove me crazy when it came to SEO. Optimizing a JavaScript framework website for search engines was a nightmare, especially when I didn’t fully understand SSR (Server-Side Rendering) and CSR (Client-Side Rendering) yet.

Things started to click when I discovered Next.js, GatsbyJS, and the JAMstack philosophy. Around 2019, I managed to bring one of my static websites to the #1 spot on Google — and that was when I realized something powerful:

Static websites are SEO beasts.

But I didn’t want to stop there. I wanted something more dynamic, flexible, and powerful — something that could combine the speed of static sites with the interactivity of dynamic systems.

That’s how I began designing my own architecture — a hybrid I called “Dynamic Stack Web” — blending static and dynamic rendering, harnessing both client and server power to achieve SEO efficiency without sacrificing performance.

And of course, I wrote it all in Golang — a language that, to me, represents clarity, control, and scalability.

💻 The Indie Hacker Way — Learn, Build, Survive

As an indie hacker, I don’t have a company, a boss, or deadlines — just me and my code.

I don’t have funding, so I pay for my domains, rent my VPS, and maintain my infrastructure using whatever small income I make online.

By day I delivered food as a shipper. By night I coded.
No mentors. No community. Just documentation, curiosity, and a stubborn will to figure things out.

At first, I thought I’d make money by freelancing — building websites for clients.
But then I asked myself:

“Why not build something of my own?”

And that’s how I discovered Affiliate Marketing.

🌍 Samdy.vn — When an Indie Hacker Creates Real Value

I used what I knew about SEO, Golang, data, and user behavior to build Samdy.vn — a price comparison website that aggregates data from Vietnam’s biggest e-commerce platforms: Shopee, Tiki, and Lazada.

No ad budget. No marketing team.
I seeded the content manually — sharing links across Facebook groups, forums, and communities.

Then one day, traffic came in.
Someone clicked. Someone bought something.

And I earned 14,000₫ (~$0.50).

It wasn’t much, but it was everything. It proved that my system worked.

A month later — 500,000₫.
Then 1.7 million.
Eventually, Samdy peaked at 10 million VND/month (~$400).

Every click, every sale, every line of code — it all felt like magic.

⚠️ Growth, Trade-offs, and Lessons Learned

As traffic grew, I made a critical mistake:

I was running Samdy and 20 other websites on a single VPS — 1 Core CPU, 2GB RAM, 20GB SSD.

When traffic spiked, the server choked.
The site slowed down.
Users left.

That’s when I realized how little I knew about infrastructure optimization, VPS management, and scaling systems.

But instead of quitting, I turned that pain into knowledge.

Now, the e-commerce landscape is changing.
Crawlers are restricted, SEO algorithms are AI-driven, and data scraping is tougher than ever.

Yet, what I’ve learned remains priceless — because lessons built on failure stick forever.

🏆 From a Lone Developer to Vietnam’s Top 100 E-Commerce Websites

No growth hacks.
No ads.
No investor money.

Just pure code-driven SEO.

Within 6–8 months, Samdy.vn ranked among Vietnam’s Top 100 e-commerce websites — built entirely from scratch, powered by Golang and a relentless belief in self-reliance.

But the real success wasn’t the ranking.
It was the understanding that:

Persistence matters more than speed.

Learning from failure is more valuable than short-term wins.

Technologies change every day — but problem-solving mindset never goes out of style.

Today, I’m still an indie hacker, still building, still learning — but I’m not rushing anymore.

I know now that moving slowly, steadily, and purposefully is the only sustainable way to grow.

I might never build a million-dollar startup,
but I’m a happy indie hacker —
because I’m creating real value with my own hands and mind.

🧠 Notes

💌 More About Me

Thanks for reading Huỳnh Nhân Quốc’s article! Subscribe for free to receive new posts and support my work.

]]>