DEV Community

Cover image for The GFPV Stack My Indie Developer’s Technical
Huỳnh Nhân Quốc
Huỳnh Nhân Quốc

Posted on

The GFPV Stack My Indie Developer’s Technical

#vanillajs #webdev #go #fibergolang

The Question That Sparked a Thought

Earlier today, I stumbled upon an interesting question:

“What stack are you using?”
You’ve probably heard the classics — LAMP, LEMP, MEAN, or even the JAM Stack.

But what about the GFPV Stack?

It’s not something you’ll find in a typical developer handbook.

It’s a philosophy — one I’ve built, lived, and coded through.

So today, I want to share my journey — the path that led me to create my own stack.

A blend of simplicity, performance, and adaptability.

My Programming Journey

In the world of programming, every developer walks a unique road — shaped by choices, experiments, and mistakes that quietly sculpt our craft.

For me, that path led to the GFPV Stack, a collection of tools I didn’t just “choose” — I grew into.

This isn’t a trendy stack like LAMP, MEAN, or JAM.

It’s a reflection of my mindset: minimalist, performant, and deeply flexible.

The Early Days

Before GFPV ever existed, I began as a JavaScript developer, working primarily with Angular — a beloved framework at the time.

Everything changed the day I discovered Golang.

It was like rewiring my brain. I started questioning everything I’d learned.

By 2020, I made a decision that changed my life — I left the city and returned to my hometown to build something of my own.

No plans. No money. Just ideas, curiosity, and a stubborn heart.

I started coding in Go, not fully understanding it, but trusting the process. Every day, I wrote something new — messy at first, but pure.

That year, I didn’t make a single cent from code.

But I built something far more valuable: a philosophy.

Why Go?

If you’ve ever written Go, you’ve probably met Gorilla Mux — a common first step for most developers.

But me? I decided to skip it. I wrote my own mini-framework instead (yes, “foolishly brave,” I know).

I’ve always loved simplicity — the kind that hides elegance beneath discipline.

Go made me think in clean lines. It taught me to care about performance, clarity, and focus.

I read everything I could — from Go vs. Rust debates to Vlang comparisons. In the end, Go won my heart.

It was light, strong, and surprisingly poetic in its precision.

Discovering Fiber

In Go’s ecosystem, there are so many frameworks — Gin, Echo, Beego, and of course Mux.

Coming from Angular, I had a soft spot for NestJS (built on top of Express). Its structure and organization inspired me deeply.

So, I tried to build my own Express-style Go framework… until one day, I discovered Fiber (back in version 1).

It was love at first benchmark.

Fiber was fast — ridiculously fast. Lightweight. Familiar.

It felt like the missing bridge between simplicity and power.

Since then, Fiber has been my go-to framework for backend systems.

PostgreSQL: The Rise of the Elephants 🐘

From my earliest Go projects, PostgreSQL became my steadfast companion.

Reliable. Scalable. Elegant.

I often joke about “the rise of the elephants” — because that’s how I see PostgreSQL: a herd of powerful, graceful creatures marching through the toughest workloads.

Most Go and Python developers I know swear by it — and I’m proudly one of them.

Even today, PostgreSQL remains my default choice for nearly every project.

Vanilla JS: Returning to Simplicity

Now, this might surprise you — Vanilla JS.

Yes, I’ve used Angular. I’ve tried React. I even wrote my own tiny framework at one point.

But I came back to the roots for one simple reason: control.

Vanilla JS gives me simplicity, stability, SEO friendliness, and security — without the chaos of node_modules and dependency hell.

I grew tired of version mismatches, constant updates, and bloated builds.

So I stripped it all away. One CDN, pure JS — that’s all I need.

I began experimenting with Web Components, loading everything via CDN.

Sure, new frameworks like Qwik JS and Shadcn look exciting — but I’m not afraid of being “behind the trend.”

Because I’m not running a race. I’m walking my own path.

On Security

One of the reasons I trust Vanilla JS is security.

When I write code, it’s mine — no hidden dependencies, no mystery scripts.

I use HttpOnly cookies for sensitive data and render templates directly from the server, embedding secure signatures into the response.

This lets me protect APIs from exposure and keep my frontend closely tied to the backend.

I even wrote a custom DNS distribution algorithm to control domains and clients dynamically — part of my deeper security layer that I can’t fully reveal here.

But in short, I don’t just build software — I build trust into the system itself.

So, What Is the GFPV Stack?

GFPV isn’t just a set of tools.

It’s a reflection of a philosophy.

Each letter represents both a technology and a principle I live by:

G – Golang

A sharp, efficient, and minimal language that feels like a craftsman’s tool — powerful yet disciplined.
F – Fiber Framework

A natural extension of Go’s simplicity. Fast, expressive, and flexible enough for real-world scale.
P – PostgreSQL

My loyal workhorse — robust, dependable, and endlessly scalable.
V – Vanilla JS

The purest form of frontend freedom. No build tools. No dependencies. Just me and the browser.

The Philosophy Behind It

Beyond the tech stack, GFPV also represents values:

  • G (Go) → Simplicity: The best solutions are often the simplest ones.
  • F (Flexibility) → Adaptability: Change is constant. Code should evolve easily.
  • P (Performance) → Efficiency: Performance isn’t just speed — it’s mindfulness in how we use resources.
  • V (Versatility) → Creativity: Great developers are problem-solvers, not tool-followers. ## Variations and Experiments

GFPV isn’t dogma.

Sometimes I swap Go for Python or Node.js, or use Gin, Echo, or even Django depending on the project.

While PostgreSQL is my anchor, I’ll turn to MySQL or Redis if it fits better.

Even on the frontend, I occasionally experiment with React, Vue, or QwikJS when needed.

Because in the end, tools don’t define us — how we use them does.

Four Years of Learning and Making

Looking back, the past four years have been filled with one lesson:

“Tools are just vehicles. The real journey is in how you think and build.”
My path may look different from others’, but that’s what makes it mine.

When I first touched Go and Fiber, I didn’t know what I was building — only that I loved the process.

Now, as I explore ideas like Indie Making and Building in Public, I realize my GFPV journey embodies those principles.

I create, I share, I learn — and in doing so, I grow.

Why the GFPV Stack Matters

To me, the GFPV Stack is more than a toolkit.

It’s a mirror of how I see software — simple, adaptable, and human.

Every finished project feels less like a product, and more like a story — one written in code, mistakes, and persistence.

Technology evolves fast, but philosophy endures.

So I’ll keep refining GFPV, one line of code at a time —

quietly, passionately, and in my own 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.

Top comments (0)