The Kind of Developer I Pretended to Be
There are two types of developers.
The first one says they’re “just prototyping” and somehow ends up with a Kubernetes cluster, three queues, a cache layer, and a monitoring dashboard for a side project that stores exactly seven records.
The second one is me.
The guy who spent way too long insisting:
“Nah. Keep it simple.”
For the longest time, my portfolio was exactly that.
Simple.
My website was built with Next.js. Static pages. Fast. Easy to deploy. No unnecessary machinery waiting to betray me later.
Life was good.
The Blog Problem Nobody Warned Me About
Then I wanted a blog.
Like every developer with a functioning ego, I thought:
“Surely someone else has already solved this.”
So I tried Hashnode.
It worked.
Until it didn’t.
Don’t get me wrong—it was a solid platform. But every time I wanted to tweak something, customize something, or make it feel like my website instead of my profile trapped inside someone else’s product, I hit another wall.
Eventually I got annoyed.
And annoyance is one of the most reliable fuels in software development.
So I built my own blog.
The First Version Was Innocent Enough
The first version was honestly pretty nice.
A React dashboard.
Firebase.
Next.js fetching blog posts.
Simple enough.
Dashboard
│
Firestore
│
Next.js
For a while, that architecture did everything I needed.
Write blog.
Publish.
Website updates.
Done.
Every time someone suggested I should build a backend, I usually responded with something like:
"Why would I do that to myself?"
Adding another server just because it sounds more “serious” has never really appealed to me.
I’ve also watched developers proudly announce they spent $200 or $300 a month hosting what is basically a frontend politely asking a REST API for permission to exist.
Congratulations, I guess.
My wallet would prefer not to be involved in that lifestyle.
So I kept things simple.
Or at least I kept telling myself I was keeping things simple.
The Part Where the Project Stopped Being Small
Then the project kept growing.
Projects.
Skills.
Experience.
Recommendations.
Embeds.
Comments.
Authentication.
User settings.
More blog features.
Suddenly both my dashboard and my website knew far too much about my database.
Every new feature meant touching multiple places.
Every tiny change started feeling like a group project with bad communication.
And then came the thing that finally broke my stubbornness.
The AI Reality Check
AI.
Not because AI magically requires a backend.
But because I could see where this project was heading.
AI-assisted writing.
SEO generation.
Content workflows.
Automation.
Scheduling.
Things that had absolutely no business living inside a React component like some kind of cursed experiment.
That’s when I finally admitted something to myself.
I wasn’t building a portfolio anymore.
I was slowly building a platform and pretending it was still “just a personal site.”
Four Weekends of Denial Later
So...
I spent my weekends building a backend.
Well...
Not a weekend.
Four weekends.
Two Saturdays.
Two Sundays.
An unreasonable amount of coffee.
Several moments of staring at Firestore like it had personally insulted me.
And at least one existential crisis caused by TypeScript doing what TypeScript does best: reminding me that confidence is a mistake.
Normal weekend activities.
The Upgrade Nobody Will Notice
The funny thing is that nothing looks different.
The dashboard still looks like my dashboard.
The website still looks like my website.
Nobody visiting the site will notice anything changed.
Which, honestly, is exactly how infrastructure should behave when it isn’t actively ruining your day.
The difference is underneath.
Instead of every application talking directly to the database, everything now goes through one API.
One place for business logic.
One place for validation.
One place for authentication.
One place to build whatever nonsense comes next.
The frontend became... just a client.
A very pretty client. But still.
What This Actually Unlocks
The part I’m most excited about isn’t that I now have a backend.
It’s what having one unlocks.
Adding new features no longer starts with:
"Where should this logic live?"
Now the answer is obvious.
The backend.
Whether it’s AI, analytics, scheduled publishing, image processing, or some future idea I haven’t regretted yet, I finally have a proper home for it.
Still Local, Still Dangerous
The best part?
It’s still sitting on my local machine.
Not deployed.
Not public.
Not replacing my production site.
Yet.
This post is being written while everything is still running locally, which feels fitting because nothing says “confidence” like documenting a system before it has had the chance to embarrass you in production.
The backend is finished.
The React dashboard has already been migrated to use it.
The public Next.js site is next.
After that comes deployment.
So this article is less of a launch announcement...
...and more of a checkpoint.
One of those moments where you stop for five minutes, look at the commit history, and realize you’ve accidentally built something much bigger than the thing you started with.
The Joke Was On Me
I spent a long time trying to avoid building a backend because I wanted to keep things simple.
Ironically...
Building the backend is what finally made everything simple again.