A Year of Growth: From Basics to Building Big

The Turning Point

It's amazing how much a person can change in a single moment—or over the course of a year. Looking back exactly one year from today, I see a different version of myself: someone who loved coding but felt trapped in the basics, unable to break through to the next level. High-level projects loomed like mountains I couldn't climb, and complex systems felt like distant dreams.

Similar to what I wrote about in the paradox of self-awareness, sometimes we need to fully acknowledge where we are before we can move forward.

Sometimes the biggest growth happens when we're brave enough to acknowledge where we're stuck.

Finding Guidance

One year ago today, I made a decision that would change everything—I reached out to my mentor. After two years of learning to code, I was still stuck in that frustrating middle ground. I could handle intermediate projects, but anything more complex felt out of reach, like trying to grasp smoke.

Then I met my mentor, and everything shifted. He didn't just teach me to code; he showed me how to think about software. From mastering data structures and algorithms to the art of software design—he helped me see the bigger picture. It wasn't just about writing code anymore; it was about crafting solutions.

This journey of transformation reminds me of what I wrote about in reflections on change—how sometimes the most significant growth comes from being open to new perspectives.

The Learning Sprint

For three intense months, I immersed myself in everything from fundamentals to advanced concepts. It was like learning a new language and suddenly understanding poetry in it. My mentor guided me through:

1. Data Structures & Algorithms: Not just memorizing them, but understanding their soul
2. Software Design: The architecture of ideas, the blueprint of solutions
3. Planning & Execution: Breaking down mountains into manageable hills

Much like my experience in how i becoming dev, this intensive learning period was transformative, changing not just what I knew, but how I thought about coding entirely.

"Don't just write code—craft solutions. Every line should have a purpose, every function a story."

Embracing Failure

Armed with new knowledge and burning ambition, I dove into the startup world. I built two startups. They both failed—spectacularly. But here's the thing about failure: it's the world's most effective teacher.

This experience resonates with what I explored in shattered trust betrayal and resilience—how sometimes our biggest setbacks can lead to our most important growth.

These failures taught me more than any tutorial ever could. They showed me that:

• Theory and practice are different beasts
• Real-world problems don't come with documentation
• The fastest way to learn is to build something real

The Technical Evolution

After those initial setbacks, I didn't retreat—I evolved. I started exploring territories that once terrified me:

• Built a web server from scratch using Rust
• Created a game engine from the ground up
• Developed Baksal, a multiplayer game inspired by chess.com for the Nepali audience
• Crafted developer tools and image formatters
• Dove deep into system architecture

Each project was a step into the unknown, a challenge that pushed me further than I thought I could go.

The Mental Battle

But this growth came with a price. As my technical skills flourished, my anxiety levels rose. The year became a paradox: as I grew stronger in coding, my mental health needed more attention.

I found myself struggling with overthinking and self-consciousness more than ever:

• Coding for 16-hour stretches
• Unable to take breaks even when I needed them
• More isolated than ever before
• Struggling with increased anxiety and self-doubt

Even on my "day off," I'd find myself coding through the night, driven by an almost manic inspiration. My VS Code screen time hit record highs, and my social time hit record lows. This led to feeling alone while surrounded by people and opportunities.

Finding Balance

This year has been transformative, but it's also taught me hard lessons about balance. While I can now build almost anything I envision, I'm learning that technical growth shouldn't come at the cost of mental health.

The process of reconnecting with myself has been crucial in finding this balance.

Growth isn't just about what you can build—it's also about building a sustainable relationship with your craft.

I've become more cautious, perhaps too much so. The world outside my coding environment feels more distant, and I'm still learning to navigate this new reality. It's a journey of finding equilibrium between the drive to create and the need to take care of myself.

A Message to Fellow Learners

Recently, I talked with a friend who's just starting his coding journey. He comes from a non-technical background and struggles with the basics. Every tutorial feels like a mountain, and building even simple projects seems impossible.

This post is for you, my friend, and for everyone else at the beginning of their journey:

1. It's okay to struggle: The basics are hard because they're fundamental. Take your time.
2. Everyone starts somewhere: A year ago, complex projects terrified me. Now they excite me.
3. Persistence matters more than talent: Keep pushing, keep building, keep learning.
4. Find your mentor: The right guidance can illuminate the path ahead.
5. Build real things: Don't get stuck in tutorial hell. Build something, anything.

Looking Forward

This year has been my best yet in terms of technical growth. I've learned more than I ever thought possible, built things I once thought were beyond my reach, and discovered strengths I didn't know I had.

Projects That Shaped Me

Looking back, certain projects stand out as major turning points in my journey. Each one taught me something unique and pushed me to grow in different ways:

The Web Server Project

Building a web server from scratch in Rust was like trying to understand how a car works by building one. It forced me to learn about:

• Network protocols and how the internet actually works
• Memory management and performance optimization
• The importance of proper error handling
• How to write maintainable systems-level code

This project, more than any other, showed me that what seems impossible at first becomes possible with persistence and patience.

The Game Engine Adventure

Building a game engine from scratch became a transformative deep dive into software architecture. This ambitious project pushed me to master:

• Applied mathematics for collision detection and physics simulations
• Real-time rendering pipelines using OpenGL shaders
• Entity-component-system patterns for scalable state management
• Performance optimization techniques for 60FPS consistency

The Custom Chat Protocol

Developing a secure communication protocol revealed the intricate dance of networked systems. This challenge required:

• Designing efficient binary serialization formats
• Implementing reliable message routing with low-latency guarantees
• Mastering concurrency patterns for real-time messaging
• Building robust end-to-end encryption using modern cryptographic primitives

The Anti-Meme Language

Creating a programming language for serious technical communication became an unexpected lesson in structural rigidity. This formalization project taught me:

• Developing lexer/parser systems that enforce formal mathematical notation
• Optimizing bytecode generation for cryptographic security guarantees
• Prioritizing computational integrity over any form of humor injection
• Building developer trust through rigorously documented error codes

Baksal - The Multiplayer Game

Building Baksal was special because it wasn't just about coding—it was about creating something for my community. This project taught me:

• Real-time multiplayer architecture
• Cultural considerations in software design
• Community management and user feedback
• The importance of user experience

Lessons Beyond Code

Through these projects and experiences, I've learned lessons that go beyond technical skills:

On Learning

• Documentation is your friend, but understanding comes from doing
• The best way to learn is to build something you care about
• When stuck, step back and break the problem down
• Sometimes the solution is simpler than we think

On Building

• Start small, but dream big
• Perfect is the enemy of done
• User feedback is gold
• Test early, test often

On Growth

• Progress isn't linear
• Celebrate small victories
• Learn from failures
• Share what you know

The Road Ahead

As I look to the future, I have several goals and projects in mind:

Technical Goals

1. Deeper Systems Understanding: I want to explore operating systems and low-level programming more deeply
2. Cloud Architecture: Building scalable, distributed systems
3. Machine Learning Integration: Incorporating AI into my projects
4. Mobile Development: Expanding into cross-platform mobile apps

Personal Goals

1. Better Work-Life Balance: Finding harmony between coding passion and personal life
2. Open Source Contribution: Giving back to the community
3. Building in Public: Sharing my journey and learning from others

Each of these projects aligns with my goal of not just building software, but building community and helping others grow.

Embracing the Journey

Looking back at the paradox of being 17, I realize how much has changed and how much remains the same. The enthusiasm, the drive to create, the desire to learn—it's all still there, just more focused and refined.

But I've also learned that success in tech isn't just about technical brilliance. It's about:

• Finding balance between passion and self-care
• Building sustainable practices
• Acknowledging both victories and struggles
• Sharing our journey to help others
• Creating space for growth and reflection
• Maintaining curiosity while building expertise
• Staying humble while growing confident

As I look toward the next year, I'm excited but also more mindful. The sky's still the limit, but I'm learning to enjoy the climb as much as the view from the top. I'm discovering that the journey itself—with all its challenges, victories, and lessons—is what makes this field so rewarding.

To everyone on their own coding journey: keep pushing, keep building, but remember to take care of yourself along the way. The road might be tough, but you're not walking it alone.

Community and Connection

One of the most valuable lessons I've learned is the importance of community. Whether it's:

• Online forums where we share knowledge
• Local meetups where we connect face-to-face
• Open source projects where we collaborate
• Social media where we share our journeys

These connections remind us that we're part of something bigger than ourselves. They provide support, inspiration, and sometimes the push we need to keep going.

Final Thoughts

As I wrap up this reflection on a year of growth, I'm reminded of something my mentor told me early on: "The code you write today is a gift to your future self." I now understand he wasn't just talking about clean code or good documentation—he was talking about the habits we build, the knowledge we gain, and the wisdom we develop along the way.

To those just starting: your journey will be unique, but you're not alone. To those in the middle: keep pushing, your breakthrough might be just around the corner. And to those who've made it: remember to reach back and help others up the ladder.

Related Posts

If you enjoyed this reflection on growth and learning, you might also find these posts valuable:

• How I Becoming Dev - My complete journey into software development
• Living with Anxiety - Managing mental health while pursuing tech
• Reflections on Change - Understanding personal transformation
• Reconnecting with Myself - Finding balance in the tech journey
• The Paradox of Self-Awareness - Understanding growth and self-discovery
• The Dream That Let Go - Learning from ambitious projects
• Paradox of Being 17 - Where it all began