Welcome to the Blog
A portfolio shows what I've built. This blog is about everything that happened in between.
Welcome.
If you're reading this, there's a good chance you weren't actually looking for this page.
Maybe you clicked Blog because you noticed it wasn't there the last time you visited my portfolio.
Maybe you found this through a search engine.
Maybe you're another developer exploring random portfolios on the internet.
Or maybe you're simply curious.
However you got here, I'm genuinely glad you did.
This page wasn't part of the original plan.
When I first built this portfolio, I had one simple goal: create a place that represented my work.
A place that introduced who I am.
A place that showcased the projects I've built.
A place that documented the journey that began during the 2021 lockdown when curiosity led me to write my first Telegram bot.
For a long time, that felt complete.
Until it didn't.
The more projects I built, the more I realized something was missing.
Every repository captured the destination.
None of them captured the journey.
Every project has two stories
Open one of my repositories and you'll see the finished version.
You'll see organized folders.
Meaningful commit messages.
Working features.
Documentation.
Maybe even a polished README.
What you won't see are the countless moments that happened before any of that existed.
The first terrible prototype.
The feature that sounded brilliant until I actually built it.
The bug that took six hours to understand and five minutes to fix.
The project that never got released because I realized there was a better idea waiting on the next branch.
Those moments rarely survive.
Eventually they're replaced by cleaner code, better architecture, and another commit.
The repository moves forward.
The story quietly disappears.
I think that's unfortunate.
Because most of the learning doesn't happen after the project is finished.
It happens while it's still messy.
While you're confused.
While you're reading documentation for the fifth time.
While you're convinced the problem is impossible, only to discover you missed a single line of code.
Those moments shape developers far more than polished screenshots ever will.
Repositories preserve the final result.
This blog preserves everything else.
One question I ask myself surprisingly often
Sometimes I wonder...
What if I had never installed Telegram?
It sounds like an oddly specific question.
After all, it's just another app.
But life has a strange habit of changing because of ordinary decisions.
Back in 2021, I wasn't searching for a career.
I wasn't trying to become a software engineer.
I wasn't thinking about backend architecture, open source, APIs, databases, or system design.
I was simply curious.
One random download became one community.
One community became one conversation.
One conversation became another question.
Then another.
Eventually those questions became tiny projects.
Those projects became habits.
Those habits slowly became the person writing this post today.
Looking back, I don't think Telegram changed my life.
Curiosity did.
Telegram just happened to be where curiosity found me.
And that's a difference I never want to forget.
Because it reminds me that sometimes the smallest decisions quietly become the biggest turning points.
Becoming
If you've looked around this portfolio, you already know a little about me.
I'm sixteen.
I'm balancing Class 12 with software development.
I spend most of my free time building backend applications, experimenting with ideas, contributing to open source, and trying to understand how good software is designed.
But none of those things define the finish line.
They're simply where I am today.
Sometimes people look at a portfolio and assume it represents the finished version of someone.
I don't think mine does.
Mine represents a snapshot.
An unfinished chapter.
A work in progress.
Every project here exists because another project came before it.
Every skill exists because I once knew absolutely nothing about it.
Every repository marks another point on a timeline that's still being written.
Five years from now, I hope I look back at this post and smile.
I hope some of these opinions have changed.
I hope the code I've written today feels small compared to what I'll build then.
I hope this portfolio looks completely different.
Because if none of those things happen...
then I probably stopped growing.
This blog isn't about documenting who I am.
It's about documenting who I'm becoming.
Why not just write on LinkedIn?
I only recently started becoming active on LinkedIn.
It's been a great place to connect with other developers, celebrate milestones, and share what I'm currently building.
But social media moves quickly.
A post slowly disappears beneath another.
Then another.
An idea that took hours to write eventually becomes difficult to find again.
Some thoughts deserve more than a timeline.
Some lessons deserve more than a launch announcement.
Some stories deserve more than a handful of reactions before disappearing into an algorithm.
LinkedIn is where I'll share what's happening.
GitHub is where I'll publish the code.
This blog is where I'll document everything neither platform was designed for.
The late-night ideas.
The failed experiments.
The engineering decisions.
The books that changed how I think.
The movie that unexpectedly inspired a feature.
The conversations that quietly reshaped my perspective.
The bugs that taught me more than successful projects ever could.
The questions that don't have answers yet.
Not every lesson belongs inside a Git commit.
Some deserve a paragraph instead.
Why keep it here?
There are already excellent platforms for writing.
Medium.
Dev.to.
Hashnode.
Ghost.
I read articles on them all the time.
They're home to some incredible writers and engineers, and they've built communities that have helped countless developers learn.
So why build my own?
Partly because I enjoy building things.
If I wanted a blog, I didn't just want somewhere to publish articles.
I wanted to build the platform too.
Designing the pages.
Writing the Markdown compiler.
Generating static pages.
Building the RSS feed.
Creating the reading experience.
It became another project—one that taught me just as much as the articles I'll eventually write here.
More importantly, I wanted everything to live together.
My projects.
My journey.
My writing.
My experiments.
One website.
One story.
This portfolio has never been just a place to showcase what I've built.
It's something I continue improving every time I learn something new.
The blog is simply another chapter of that project.
Building it myself also gave me something most platforms can't.
Complete freedom.
No algorithms deciding who sees a post.
No pressure to publish every week.
No templates telling me how a blog should look.
Just a blank page.
A keyboard.
And the freedom to write whenever I have something worth remembering.
I like that.
It feels more personal.
And somehow...
More honest.
This isn't just another developer blog
The internet already has thousands of incredible developer blogs.
Many are written by engineers with decades of experience.
People who've built systems I'll spend years trying to understand.
This isn't that.
I'm not writing from the finish line.
I'm writing from somewhere in the middle.
I'm still learning.
Still experimenting.
Still changing my mind.
Still asking questions I don't know the answers to.
Maybe that's exactly why this blog should exist.
Because not every story needs to come from someone who's already reached the destination.
Sometimes it's interesting to hear from someone who's still walking toward it.
Sometimes the journey is the part worth documenting.
And that's exactly what I hope to do here.
More than just code
Programming happens to be the language I spend most of my time speaking.
But curiosity doesn't stop when I close my editor.
Sometimes a book completely changes how I approach a problem.
Sometimes a movie unexpectedly sparks an idea for an entire project.
Sometimes a random conversation sends me down a rabbit hole I never expected to explore.
And sometimes the biggest lesson has absolutely nothing to do with software.
This blog isn't about pretending I have everything figured out.
It isn't about trying to become another tutorial website.
And it definitely isn't about writing because I feel like I have to.
It's about documenting the questions worth asking.
Because those questions have taken me further than any roadmap ever has.
Something I've been thinking about
Over the past few years, I've met a lot of incredibly talented people.
Some through Telegram.
Some through GitHub.
Some through open source.
Some through communities that probably have no idea how much they influenced me.
Many of them built incredible things.
Some disappeared.
Not because they lacked talent.
Not because they stopped caring.
Life simply asked them to take a different path.
School.
Family.
Responsibilities.
Financial realities.
Different priorities.
It made me realize something.
Talent exists almost everywhere.
Opportunity doesn't.
I often wonder how many brilliant developers, designers, artists, writers and creators the world never gets to see—not because they weren't capable, but because life quietly pulled them somewhere else.
Whenever I think about that, I'm reminded how fortunate I was.
One random download.
One curious afternoon.
One community.
One question.
Those tiny moments slowly changed the direction of my life.
I don't take that for granted.
Maybe someone else is at the beginning
If you're reading this while learning your first programming language...
Building your first project...
Wondering whether you're good enough...
Or questioning whether it's already too late...
I hope you keep going.
Not because everyone should become a software engineer.
But because curiosity deserves a chance.
The first project probably won't be impressive.
Mine certainly wasn't.
The second probably won't be either.
That's okay.
Nobody starts with their best work.
Every developer you admire once stared at an empty editor wondering where to begin.
The only difference is that they kept writing.
They kept building.
They kept asking questions.
If this blog can encourage even one person to do the same, then it'll already be worth having.
I don't want people to become developers like me.
I hope they become developers far better than me.
I hope they build things I'll never think of.
I hope they solve problems I'll never get the opportunity to solve.
And if one small story here quietly helps someone take that first step...
That would mean more to me than any number on an analytics dashboard.
A few questions you might have
Will you post regularly?
Hopefully. But I don't want writing to become another streak to maintain. I'd rather disappear for a month and come back with something worth reading than publish simply because a calendar expects me to. Quality has always mattered more to me than quantity. I hope this blog reflects that.Will every post be about programming?
No. Programming is a huge part of my life, but it isn't the only thing that inspires me. You'll find project stories. Technical deep dives. Open-source experiences. Books. Movies. Random ideas. Productivity experiments. Things I'm currently learning. And occasionally, thoughts that have nothing to do with software—but everything to do with curiosity. If I think it's worth remembering... It's probably worth writing about.Why isn't there a comment section?
That was intentional. I wanted this blog to stay simple, lightweight, and focused on reading. If something here resonates with you, challenges your perspective, or starts a conversation, I'd genuinely love to hear from you. You'll find links to my GitHub, LinkedIn, Telegram, Instagram, and other social platforms throughout the portfolio. Feel free to reach out. Some of the best conversations don't happen in comment sections anyway.Will your opinions change?
I hope they do. If I read these posts a few years from now and disagree with some of them, that'll probably mean I've learned something new. Growth should leave evidence. This blog is that evidence.A small philosophy
I don't think learning only happens through tutorials.
Sometimes it happens while debugging.
Sometimes through open source.
Sometimes because of a book.
Sometimes because of a movie.
Sometimes because someone asked a question I couldn't answer.
The best lessons usually appear where you weren't expecting them.
That's why I keep following curiosity.
It has introduced me to incredible people.
It has helped me build projects I never imagined I'd create.
It has completely changed the direction of my life.
And I have a feeling it's only getting started.
Before you go
Maybe this blog never becomes popular.
Maybe only a handful of people ever read these posts.
That's okay.
Because I remember what it felt like searching for someone else's story.
Someone who wasn't finished yet.
Someone who was still learning.
Someone who proved that you don't need decades of experience before sharing what you've learned.
If this little corner of the internet becomes that for someone else...
Every word here will have been worth writing.
A portfolio shows the destination.
This blog documents the journey.
Maybe a few years from now I'll come back to this very post and smile at how much I still had left to learn.
I honestly hope that's true.
Because that would mean I never stopped being curious.
Thank you for spending a few minutes here.
Whether you're another developer, a student, a recruiter, or simply someone who clicked on a random page of the internet...
I appreciate you being here.
I hope you leave with at least one idea worth thinking about.
One question worth asking.
Or maybe just the motivation to build something you've been putting off.
If I can become the developer I'm hoping to become...
Why can't you?
Welcome to my corner of the internet.
I'll see you in the next story.
Built with curiosity & caffeine.
Still learning. Still building. Still becoming.