Search for a command to run...
Lessons from Code, Content, and Consistency
fundamentals still matter most. frameworks maybe 10% of the job, rest is thinking
Congrats on 100 posts! Honestly, the consistency is probably more impressive than the number itself
Congratulations for your 100th Blog 😇 Your Thoughts really helpfull, If we blog then we able to track ourself Tracking -> Improving 🔥 Improving- Better Code Readibility Better Defining Better Understanding Easy to Adapt 🔥
Reliability basics: Outbox pattern + why it matters
Introducing Kafka/Redpanda + move to event-driven workflow
Connect Orders ↔ Inventory (first working service-to-service flow)
Inventory service + gRPC + proto contracts
On this page
When I published my first technical blog, I was not thinking about reaching 100 posts. I was simply trying to explain something I had learned.
Maybe it was a bug I solved after hours of debugging. Maybe it was a concept that finally clicked after reading documentation, watching tutorials, and experimenting with code. Maybe it was something I wished I had found earlier when I was struggling.
That first blog was not perfect. It probably could have been clearer, better structured, or more polished. But it had one important thing, the intention to share knowledge.
Today, this is my 100th blog.
And instead of writing another tutorial, another technical explanation, or another step-by-step guide, I want to pause for a moment and look back at the journey.
This blog is about why I started writing, what changed after 99 blogs, the technical lessons I learned, the writing lessons that shaped me, and what I want to build next.
I started writing technical blogs because I wanted to make learning easier, both for others and for myself.
In software development, we spend a lot of time solving problems. Sometimes the solution is simple, but reaching that solution takes hours. We search through documentation, GitHub issues, Stack Overflow answers, error logs, tutorials, and random comments hidden deep inside discussion threads.
Many times, after solving a problem, I felt one thing clearly is that This should have been explained better somewhere. That thought became one of my biggest motivations. I wanted to write the kind of blogs I wished I had when I was learning.
I wanted to explain technical concepts in a simple way. I wanted to document errors and their solutions. I wanted to break down tools, frameworks, and programming ideas so that someone else could save time and understand things faster.
But writing was not only about helping others. It also helped me. Because when you write about a topic, you cannot hide behind vague understanding. You have to slow down. You have to ask yourself that, Do I really understand this? Can I explain it simply? Can I give an example? Can someone new to this topic follow my explanation?
That process made me a better learner.
After 99 blogs, a lot changed. The biggest change was not only in my writing. It was in my thinking.
Earlier, when I learned something new, I mostly focused on making it work. If the code ran successfully, I moved on. But writing technical blogs changed the way I approached problems. Now I think more deeply. I ask why something works, not just how to make it work.
I pay more attention to edge cases, errors, performance, readability, and real-world usage. I try to understand the concept behind the command, the reason behind the pattern, and the trade-off behind the solution.
My coding also improved.
When you know that you may explain your code later, you naturally start writing cleaner code. You choose better names. You organize your logic. You avoid unnecessary complexity. You think about whether another developer would understand your solution.
My debugging improved too.
Writing about errors taught me that debugging is not just fixing problems. It is a structured process. You observe the error, understand the context, isolate the cause, test possible solutions, and document what worked.
Explaining concepts also became easier with time.
In the beginning, I sometimes tried to explain everything at once. But after writing many blogs, I learned that good explanation is not about adding more information. It is about arranging information in the right order.
Start with the problem. Explain the concept. Show an example. Break it down. Mention common mistakes. End with a clear summary.
That simple structure changed the way I write and teach. Most importantly, writing gave me confidence.
Publishing 99 blogs taught me that consistency matters more than perfection. Every blog does not need to be viral. Every post does not need to be the best thing I have ever written. But every blog should add value. That mindset helped me continue.
After writing so many technical blogs, some lessons kept repeating again and again.
The best technical solutions are often simple. It is easy to make code complex. It is easy to add more layers, more abstractions, more functions, and more clever logic. But simple code is easier to read, test, debug, and maintain.
A solution is not better because it looks advanced. A solution is better when it solves the problem clearly.
Good documentation saves time. Many developers underestimate documentation until they need it. A well-written README, clear setup steps, useful comments, and proper examples can make a huge difference.
Documentation is not separate from development. It is part of the developer experience.
Debugging is not luck. It is not just copying an error message and trying random solutions. Good debugging requires patience, observation, and logical thinking.
You need to understand what changed, where the issue appears, what the system expected, and what actually happened. Every error teaches something if you take time to understand it.
Variable names, function names, file names, and component names matter more than we think. Good names reduce confusion. Bad names create mental load.
A clear name can sometimes remove the need for an extra comment. It tells the next developer what something is supposed to do. And many times, that next developer is your future self.
Frameworks change. Libraries change. Tools change. But fundamentals stay valuable.
Programming logic, data structures, algorithms, databases, networking, operating systems, APIs, security, and system design continue to matter no matter which technology stack you use.
The deeper your fundamentals, the easier it becomes to learn new tools.
Reading is useful. Watching tutorials is useful. But building is where understanding becomes real.
When you build something, you face problems that tutorials often skip. You make decisions. You deal with errors. You connect different pieces together.
That is where real learning happens.
Writing technical blogs taught me as much about communication as it did about technology.
Theory is important, but examples make concepts understandable. A beginner may not understand a long definition immediately, but a simple example can make the idea clear in seconds.
Whenever possible, show the code. Show the input. Show the output. Show the mistake. Show the fix. Examples make learning practical.
When writing technical content, it is easy to assume that readers already know certain things. But many readers are beginners. They may not know the command, the folder structure, the reason behind an error, or the meaning of a technical term.
Clear writing respects the reader. It does not make them feel small for not knowing something. It guides them step by step.
Some concepts are easier to understand visually. Architecture, request flow, database relationships, deployment pipelines, authentication, caching, and system design topics often become clearer with diagrams. A simple diagram can explain what paragraphs of text cannot.
A good blog is not just a collection of information. It needs flow. The order matters.
Start with why the topic matters. Then explain the problem. Then introduce the solution. Then show implementation. Then explain what is happening. Then summarize.
When the structure is clear, readers stay with you.
This may be the biggest writing lesson I learned. If I waited for every blog to be perfect, I would not have reached 100.
Some blogs will be better than others. Some will get more views. Some will help only a small number of people. That is okay. The goal is to keep improving.
Each blog teaches something. Each post makes the next one better.
Among the 99 blogs I have written so far, some are special to me.
Some were difficult to write. Some solved real problems. Some received great feedback. Some helped me understand a topic deeply. Some remind me of a specific stage in my learning journey.
Here are a few of my favorite blogs
Flutter Widget in Detail: Container : This blog is special because it represents the beginning of my technical writing journey. This blog reminds me that every big journey starts with something small.
Flutter Bloc: A Complete Guide: State management is one of the most important topics in Flutter development, and Bloc played a big role in my learning journey. This was one of those blogs where writing made the concept clearer for me too.
Understanding Streams: Everything You Need to Understanding Streams: Streams are one of those concepts that can feel confusing at first, but once they click, they unlock a deeper understanding of asynchronous programming. It taught me that fundamentals are always worth writing about.
Testing In Flutter: Unit Test, Widget Test, and Integration Test The testing series is special because testing is often ignored by beginners, but it becomes extremely important as applications grow. This series helped me appreciate clean, testable code.
Becoming an Expert in Flutter with Clean Architecture: This series marked an important stage in my Flutter journey. This blog series is one of my favorites because it represents the transition from writing code that works to writing code that scales.
From Zero to Go Hero: Learn Go Programming with Me: This series is special because it shows my move beyond Flutter and into backend development. This series reminds me that growth as a developer often starts when we step outside our comfort zone.
Step-by-Step Guide to Secure Authentication in Go using JWT and Fiber : Authentication is one of the most practical and important parts of backend development. This blog is one of my favorites because it moved from just learning Go to building something useful with it.
Building Scalable Go Application With Docker, AWS, and GitHub Actions : This blog represents another important shift in my journey: from building applications to thinking about how they are shipped. This topic made me think more like an engineer responsible for the full lifecycle of an application.
Diving Into Docker: The Docker series is one of my favorite recent series because Docker is a tool that changes how developers build, run, and deploy applications. It also connected many dots between local development, deployment, scalability, and distributed environments.
A Practical Journey from Application to Distributed Systems: This series feels like one of the most meaningful parts of my journey so far. Writing this series helped me move from application-level thinking to system-level thinking.
These blogs are not just links. They are milestones.
Each one represents a problem solved, a concept learned, or a moment where I chose to share instead of keeping the knowledge to myself.
Reaching 100 blogs feels special, but it does not feel like the end. It feels like the beginning of the next phase. After 100 blogs, I want to write with more depth, more clarity, and more purpose.
I want to create deeper tutorials that do not just show how to build something, but also explain why certain decisions are made.
I want to explore more real-world projects, open-source contributions, system design topics, AI tools, developer productivity, backend architecture, frontend patterns, cloud deployment, and practical engineering lessons.
I also want to experiment with different formats. Maybe newsletters. Maybe videos. Maybe visual guides. Maybe project-based series. Maybe detailed case studies. Maybe open-source learning resources.
Technology changes quickly, but the habit of learning remains valuable forever.
Writing 100 technical blogs taught me that knowledge grows when it is shared. A blog may start as a small explanation, but it can help someone debug an issue, understand a concept, complete a project, or feel less stuck. That is powerful.
To everyone who has read, shared, commented on, or learned from any of my blogs: thank you.
And to anyone thinking about starting technical writing, my advice is simple: Start with one blog.
Do not wait until you know everything. Do not wait until your writing is perfect. Do not wait until you feel completely ready. Write what you are learning. Explain what confused you. Share what helped you. Document what you solved.
Because one blog can become ten. Ten can become fifty. And someday, without even realizing it, you may be writing your 100th.
This is my 100th blog.
And I am just getting started.
