I started learning how to code during a transitional period in my life when I found myself having too much free time. With a background in engineering, business, and data analytics, I was looking for something that would challenge me, keep my mind sharp, and maybe even spark a new direction in my career. Learning to code felt like the perfect mix of logic, creativity, and problem-solving, so I dove in. At first, it was just a fun experiment, but it quickly turned into something much bigger.
I started with online bootcamps and YouTube tutorials, jumping between programming languages and building small projects just to see what I could do. The learning curve was steep, the documentation often confusing, and Stack Overflow… well, both a lifesaver and a source of existential doubt. But the more I learned, the more I wanted to push myself. I began working on personal projects, and I even set up and managed my own remote VPS to self-host a handful of microservices – because why not make things a little more complicated, right?
Eventually, I felt confident enough to start applying what I’d learned in a more professional setting. I landed a part-time junior software engineer role, which later grew into a full-time position. That leap – from learning at home to contributing to a real-world codebase – was huge. It came with challenges, imposter syndrome, and more than a few “what am I even doing?” moments, but also a ton of growth. Needless to say, it has been a humbling, empowering, and sometimes chaotic experience.
This post and the following series are my way of sharing the lessons I’ve learned so far with anyone just getting started or thinking about taking the leap into software development. Whether you’re a career changer, a bootcamp grad, or a self-taught coder grinding through tutorials, I see you – and I’ve been there. But along the way, I’ve picked up a lot of lessons – many the hard way – that I wish someone had told me when I started out. I hope my story can offer you some guidance, encouragement, and maybe even a few laughs. I definitely don’t have it all figured out (spoiler: no one does), but I have picked up some valuable insights along the way.
So if you’re looking for a little validation that you’re not alone in this messy, wonderful process, keep reading. I’ve got stories, tips, and encouragement coming your way. Let’s figure this out together.
Just Get Started
When I first jumped into coding, I was completely overwhelmed by the endless options – Python, JavaScript, React, Docker, APIs, databases, you name it. I felt like I had to learn everything at once just to keep up. So I did what a lot of people do: I started cranking through online courses (shout out to Udemy) as fast as I could, just trying to “complete” them. But the problem was, I wasn’t actually absorbing much. I was moving so quickly that none of it really stuck.
Eventually, I realized I needed to slow down and change my approach. Instead of trying to learn all the “right” tools at once, I picked one topic that interested me and focused on understanding it deeply – learning it, applying it, and building something small with it. Suddenly, things started to click. I wasn’t just checking boxes anymore; I was actually enjoying the process and seeing progress.
The big lesson? Don’t worry about the perfect place to start – just start. Pick something that genuinely excites you and follow that thread. You’ll find that topics naturally build on each other. And before you know it, you’ll look back and see how all those little steps added up to something real – like a project you built entirely on your own. (Need proof? Check out one of my first full projects here – humble beginnings and all.)
It’s not about speed. It’s about consistency, curiosity, and giving yourself permission to learn one thing at a time.
Learn How to Search
One of the most valuable skills you can develop as a software engineer isn’t knowing the right answer – it’s knowing how to find it. Seriously, no one (and I mean no one) has all the answers memorized. What makes a developer good – nay, great – is their ability to search smart, filter through the noise, and find exactly what they need to move forward.
It’s tempting, especially today, to just ask AI for every solution. And don’t get me wrong – AI is an incredible tool. But becoming too reliant on it can short-circuit your ability to problem-solve and research independently. The internet is full of gold: official docs, GitHub issues, blogs, tutorial sites, forum threads, and of course, Stack Overflow (praise be). Most of the time, your “unique” bug or obscure error message has already been posted – and fixed – by someone else.
The real trick is learning how to ask the right questions, both to Google and to other humans. That means including error messages, relevant keywords, and stripping away all the fluff. The better your question, the faster you’ll find your solution.
It’s okay to struggle. In fact, struggling to find the right answer and refusing to give up is what builds the persistence and intuition you need as a developer. So get comfortable with the search bar – it’ll be your best friend in this field.
Rules Matter… Eventually
Every language, framework, and tool has its own set of rules, conventions, and best practices. And yes – those are important. But when you’re just starting out, don’t let the pursuit of perfection stop you from actually building and learning.
I remember early on trying to make my code “look” like a senior dev wrote it. I obsessed over clean syntax, perfect indentation, proper linting, and textbook documentation. But here’s the thing: none of that matters if your code doesn’t work. Functionality should come first. Make it work, then make it better. Clean code is great, but working code is essential.
This goes for everything from formatting to file structure to Git workflows. I used to stress over following proper Git etiquette – branches, commits, pull requests, the whole deal. But if you’re working on your own personal project, it’s okay if your commit history is messy or your main branch is chaos. What matters is learning how to use the tool. The polish comes with practice and experience.
Over time, you will start to understand why the rules exist – and that’s when they’ll actually stick. But don’t let trying to do everything the “right” way slow you down when you’re just getting started. Focus on building, breaking, and understanding. The rest will follow.
Build Something You Care About
At the end of the day, the best way to learn how to code is to actually build stuff. You can watch a hundred tutorials, but nothing will teach you more than rolling up your sleeves and getting your hands dirty with a real project. The magic happens when you hit a wall, Google a dozen error messages, try three different approaches – and finally, something clicks.
Build something that you care about. It doesn’t need to be flashy or groundbreaking. It just needs to be something that keeps you coming back. Whether it’s a habit tracker, a portfolio site, or a goofy web app that solves a personal itch – when you’re invested in what you’re building, you’ll push through the tough parts and actually enjoy the process.
And don’t be afraid to break things – on purpose. Try weird ideas. Refactor messy code. Deploy something and watch it crash, then fix it. Each problem you solve adds another tool to your belt and deepens your understanding in a way no course can replicate.
Most importantly: ship it. Even if it’s not perfect. Even if the UI makes you cringe a little. Get used to finishing things and sharing them. That’s what developers do. And every project you complete is proof to yourself (and others) that you’re learning, growing, and actually doing the thing. (Need a laugh? Feel free to browse my early projects on GitHub for some truly questionable UI decisions and half-baked ideas – hey, we all start somewhere.)
Wrapping It Up… for Now
And there you have it – the first few steps of my journey into software development! It hasn’t always been smooth sailing, but I’ve learned a ton along the way. Whether it’s learning how to just get started, searching for solutions like a pro, or accepting that perfection comes with time, each of these lessons has helped me grow into a better developer – and I hope they’ll help you too.
But this is just the beginning. In future posts, I’ll dive into more lessons I’ve learned on my journey, including an introduction to algorithms and data structures (yes, we’ll tackle that monster), a guide to version control (Git is your friend, promise!), debugging strategies that actually work, the art of proper code documentation (hey… rules do matter, eventually), and so much more. So, check back often as I continue to share what I’ve picked up along the way. Thanks for reading, and remember – if I can do this, so can you!