Building in Public: Why I Started This Blog to Share My Learning Journey

The Moment I Decided to Start Sharing

I was three hours deep into debugging a recursive algorithm when it finally clicked. That "aha!" moment felt incredible. But then I thought—what if I could help someone else have that same breakthrough faster?

That's when I decided: I'm starting this blog.

Not as an expert. Not as someone who has it all figured out. But as a learner who wants to document the journey, share discoveries, and hopefully make the path a little clearer for others walking the same road.

In this post, I'll share why I started this website, what I plan to write about, and why I believe learning in public is one of the best things you can do for your growth as a developer.

Why Start a Blog? My Three Core Reasons

1. Learning by Teaching is Incredibly Powerful

There's something magical about explaining concepts to others. When you try to teach something, you're forced to:

• Understand it deeply enough to explain it simply
• Fill in the gaps in your own knowledge
• Think about edge cases you might have missed
• Organize information in a logical, digestible way

I've noticed that when I explain a concept to a friend, I often discover nuances I didn't fully grasp myself. Writing forces even deeper understanding because there's no room for hand-waving—every statement needs to be clear and accurate.

My experience: Last month, I was learning about dynamic programming. I thought I understood it until I tried writing about it. That's when I realized I couldn't clearly explain the difference between memoization and tabulation. Writing forced me to go deeper, and now I truly get it.

2. Creating a Resource I Wish I Had

When I started learning data structures and dsa, I bounced between:

• Academic textbooks (too theoretical)
• YouTube tutorials (often incomplete)
• Documentation (sometimes too technical)
• Random blog posts (inconsistent quality)

What I really wanted was:

• Practical examples from a learner's perspective
• Real struggles documented, not just polished solutions
• Complete guides that cover fundamentals to advanced
• Clear explanations without assuming too much prior knowledge
• Patterns and mental models not just code

I'm building the resource I wish existed when I started. If it helps even one person learn faster or understand better, it's worth it.

3. Building My Digital Garden

This website isn't just a blog—it's my digital garden. A place where I can:

• Document my learning across different topics
• Build a knowledge base I can reference later
• Track my growth over months and years
• Connect with others learning similar things
• Showcase my journey to potential collaborators or employers

Years from now, I want to look back and see the progression. From struggling with basic loops to implementing complex algorithms. From copying code to designing systems. This blog is my time capsule.

What I'll Be Writing About

My interests span across computer science, and I want to share insights from all of them:

Data Structures & Algorithms

The foundation of everything. I'll cover:

• Classic algorithms with practical implementations
• Problem-solving patterns for coding interviews
• When to use what data structure
• Real-world applications beyond textbook examples
• Common pitfalls and how to avoid them

Programming Languages

Starting with Python, but expanding as I learn:

• Python fundamentals and advanced concepts
• Best practices and coding patterns
• Standard library deep dives
• Performance optimization techniques
• Comparing approaches across languages

Mathematics for Computer Science

Math isn't scary when you see its applications:

• Linear algebra for machine learning
• Probability and statistics for data science
• Discrete math for algorithms
• Calculus concepts in optimization
• Practical examples showing why math matters

Web Development

Building things for the web:

• Frontend frameworks like Vue and Nuxt
• Performance optimization techniques
• Design principles for better UX
• Building real projects from scratch
• Deployment and DevOps basics

Machine Learning & Data Science

As I explore AI and data:

• ML fundamentals explained simply
• Implementing algorithms from scratch
• Using popular libraries effectively
• Data visualization techniques
• Real-world projects and case studies

System Design & Architecture

How to build scalable systems:

• Design patterns and when to use them
• Scalability principles for growing applications
• Database design and optimization
• Distributed systems concepts
• Real-world architecture examples

My Content Philosophy: Learning in Public

I'm adopting the "learning in public" philosophy. This means:

1. Documenting, Not Creating

I'm not waiting until I'm an expert to write. I'm documenting what I learn as I learn it. This means:

• Fresh perspective: I remember what it's like to not understand
• Authentic struggles: I share real challenges, not polished narratives
• Growing together: Readers can learn alongside me
• Mistakes included: I'll share what went wrong and why

2. Sharing Work-in-Progress

Not everything will be perfect. Some posts will be:

• Exploratory deep dives into new topics
• Mistakes I made and lessons learned
• Works-in-progress that evolve over time
• Questions I'm still figuring out

This isn't about perfection—it's about progress.

3. Engaging with the Community

I want this to be a two-way conversation:

• Comments and feedback are welcome
• Questions help me write better content
• Corrections make me a better learner
• Discussions deepen everyone's understanding

Why Learning in Public Changed My Development Journey

Before I committed to sharing publicly, my learning looked like this:

• Learn concept → Maybe take notes → Move on → Forget details
• Struggle with problem → Eventually solve → Never document approach
• Have insight → Think "that's cool" → Lose it in a week

After committing to learning in public:

• Learn concept → Write detailed post → Understand deeply → Remember long-term
• Struggle with problem → Document journey → Create resource for others
• Have insight → Share immediately → Get feedback → Refine understanding

The difference? Accountability and depth. When you know you're going to explain something publicly, you learn it better. When you get feedback from others, you refine your understanding even further.

Real Example: My First Deep Dive

My first technical deep dive was on two-pointer algorithms. Before writing:

• Knew it existed
• Could recognize it in some problems
• Didn't fully understand when to use it

After writing a comprehensive guide:

• Understood multiple variations (opposite pointers, fast-slow, etc.)
• Created mental model for pattern recognition
• Could explain trade-offs clearly
• Discovered edge cases I hadn't considered
• Helped 20+ people understand it better

Writing transformed surface-level knowledge into deep understanding.

The Tech Stack Behind This Blog

Since this is a technical blog, here's what powers it:

Core Technologies

• Framework: Nuxt 3 (Vue.js-based)
• Content: Nuxt Content v3 (file-based CMS)
• Styling: Tailwind CSS with custom design
• Language: TypeScript for type safety
• Deployment: Static site generation (SSG)

Why These Choices?

Nuxt 3:

• Fast, modern framework
• Great developer experience
• Excellent performance out of the box
• Easy deployment

Nuxt Content:

• Write in Markdown
• Type-safe content
• No database needed
• Version control friendly

Static Generation:

• Lightning-fast loading
• Great SEO
• Free hosting options
• Highly reliable

Features I Built

• Category system for organizing content
• Tag-based filtering for easy navigation
• Reading time estimates for each post
• Code syntax highlighting for technical content
• Mobile-responsive design for any device
• Dark mode support for comfortable reading

This isn't just a blog—it's a custom-built platform optimized for sharing technical knowledge.

What You Can Expect from This Blog

Content Quality

Every post will:

• Be well-researched with verified information
• Include practical examples you can run yourself
• Feature clear code snippets with explanations
• Have working implementations tested thoroughly
• Link to additional resources for deeper learning

Publishing Frequency

I'm aiming for:

• 2-3 comprehensive posts per week (minimum)
• Deep dives on complex topics once a week
• Quick tips and insights as I discover them
• Series on major topics broken into digestible parts

Quality over quantity—but consistent delivery.

Content Length

Posts will vary based on topic:

• Quick tips: 500-800 words
• Tutorial posts: 1,500-2,500 words
• Deep dives: 2,500-4,000 words
• Comprehensive guides: 4,000+ words

Whatever length is needed to explain the concept thoroughly.

My Commitment to You

As I embark on this blogging journey, I commit to:

1. Accuracy

• Double-checking facts and code
• Testing all implementations
• Correcting mistakes quickly
• Citing sources appropriately

2. Clarity

• Explaining complex topics simply
• Using analogies and examples
• Breaking down difficult concepts
• Avoiding unnecessary jargon

3. Accessibility

• Writing for learners at various levels
• Providing context and prerequisites
• Including beginner-friendly explanations
• Offering resources for deeper learning

4. Consistency

• Publishing regularly
• Maintaining formatting standards
• Following a clear structure
• Improving based on feedback

5. Authenticity

• Sharing real struggles and solutions
• Admitting when I don't know something
• Documenting the actual learning process
• Being honest about mistakes

How You Can Join This Journey

This isn't just my journey—it's ours if you want it to be.

Ways to Engage

1. Read and Learn

• Explore topics that interest you
• Try the code examples
• Practice the concepts
• Apply what you learn

2. Provide Feedback

• Point out errors (gently!)
• Suggest improvements
• Ask questions
• Share your perspective

3. Share Your Journey

• Comment on posts
• Share what you're learning
• Connect on social media
• Build your own learning projects

4. Spread the Word

• Share posts that helped you
• Recommend to fellow learners
• Link from your own content
• Help others discover these resources

Connect with Me

Find me on:

• Twitter: @ojaswiat
• LinkedIn: linkedin.com/in/ojaswiat
• GitHub: github.com/ojaswiat

I love hearing from readers, answering questions, and connecting with fellow learners!

The Bigger Picture: Why Sharing Knowledge Matters

Beyond personal growth, there's a bigger reason to share knowledge:

The Open Source Spirit

The tech community thrives because people share:

• Open source code
• Free tutorials
• Stack Overflow answers
• Blog posts and guides
• YouTube videos
• Community forums

I've learned so much from free resources. This is my way of giving back.

Breaking Down Barriers

Not everyone has access to:

• Expensive bootcamps
• University CS programs
• Paid courses and books
• Mentorship opportunities

But everyone with internet access can read a blog post. If my writing helps someone learn who couldn't afford alternatives, that's incredibly meaningful.

Building a Better Tech Community

The tech community is at its best when:

• Knowledge is shared freely
• Beginners feel welcome
• Questions are encouraged
• Learning is celebrated
• Growth is collective

I want to contribute to that culture.

Challenges I Expect (And How I'll Handle Them)

Let's be real—blogging isn't always easy.

Challenge 1: Impostor Syndrome

The fear: "Who am I to teach this? I'm still learning myself!"

My response: That's exactly why I should share. Fresh learners often explain things better than experts because they remember the struggle. I'm not claiming to be an expert—I'm documenting my learning journey.

Challenge 2: Time Management

The challenge: Writing takes time. Coding takes time. How do both?

My approach:

• Treat writing as part of learning, not separate from it
• Write as I learn, not after
• Start with notes, expand to posts
• Block dedicated writing time weekly

Challenge 3: Staying Motivated

The reality: Some posts might not get many views initially.

My mindset:

• Writing primarily for learning, audience is bonus
• Even one person helped makes it worthwhile
• Building long-term asset, not chasing viral posts
• Tracking progress, not just metrics

Challenge 4: Handling Criticism

The fear: "What if people point out mistakes or criticize my work?"

My stance:

• Mistakes are opportunities to learn
• Constructive feedback improves content
• Critics who correct errors are helping
• Can't please everyone—that's okay

Looking Forward: What's Next?

Immediate Goals (Next 3 Months)

• Publish 25+ high-quality blog posts
• Cover fundamentals in DSA, Python, and web development
• Build comprehensive guides on key topics
• Grow readership through consistent quality
• Engage with comments and feedback

Medium-Term Goals (6-12 Months)

• Create video content for visual learners
• Launch interactive coding examples
• Build a searchable knowledge base
• Start a newsletter for subscribers
• Collaborate with other creators

Long-Term Vision (1-3 Years)

• Develop complete learning paths for different topics
• Create downloadable resources and cheatsheets
• Build a community of learners
• Potentially create courses or workshops
• Help hundreds of people break into tech

The First Step is Always the Hardest

Starting this blog felt daunting. Questions swirled:

• What if my writing isn't good enough?
• What if I make mistakes?
• What if nobody reads it?
• What if I can't maintain consistency?

But here's what I realized: The perfect moment never comes. The only way to get better at writing is to write. The only way to build an audience is to start creating content. The only way to help others is to share what you know.

So I'm starting. Imperfectly. Publicly. Consistently.

An Invitation

If you're reading this, you're here at the beginning. You're seeing the first chapter of this journey.

Whether you're:

• A fellow learner exploring computer science
• An experienced developer reminiscing about your own journey
• Someone curious about tech looking for resources
• A friend or colleague supporting my new venture

Thank you for being here.

I'm excited to share what I learn, create resources that help, and build connections with people who love learning as much as I do.

This is day one of documenting my journey in tech. I hope you'll join me for the ride.

Let's learn together. Let's build together. Let's grow together.

The best time to start sharing your knowledge was yesterday. The second best time is today.

Here's to the journey ahead! 🚀

This is the first post on my new blog! If you're also on a learning journey or thinking about starting to share your knowledge, I'd love to hear from you. Connect with me on Twitter or LinkedIn and let's learn together!

Support My Work

If this post inspired you to start your own learning journey, encouraged you to share your knowledge publicly, or if you're excited to follow along with my content, I'd really appreciate your support! Starting this blog and creating free, comprehensive content takes significant time and effort. Your contribution helps me dedicate more time to writing detailed guides and maintaining this platform.

☕ Buy me a coffee - Every contribution, big or small, means the world to me and keeps me motivated to create more content!

Cover image by Marvin Meyer on Unsplash