The path of the self-taught developer is tough and filled with uncertainty. There is no straight line from newbie to career programmer. Because of this, I believe all self-taught developers have a unique story to tell.

In this article, I’ll share my coding journey through a series of lessons I learned along the way. Hopefully reading about my experience teaching myself how to code will help you reflect on your own past, and motivate you to keep moving forward.

Lesson #1: Focus on the Process

When I first started learning to program, I never had the intention of making a career out of it. I just wanted to make a specific app.

My journey started when I was a senior in college. I just finished Richard Branson’s biography and I was probably reading too much TechCrunch. I was pumped full of entrepreneurial energy.

I was constantly reading about how college kids were receiving massive amounts of investment for their mobile app ideas. I thought I could be one of those college kids.

One day, while walking in between classes, an app idea hit me. I quickly became convinced that I’d found the next big thing.

I was consumed by the idea and stopped paying attention to lectures. My excitement for the app idea quickly grew to the point where I felt I needed to take action.

There was one big problem. My idea was a mobile app and I didn’t know anyone who could build mobile apps.

So I thought, "what the hell, how hard could programming be?" I was losing interest in my major and I was spending a lot of time playing Xbox. I could put some of my free time towards building out my mobile app idea.

Sometimes being naive helps you take action when you normally wouldn’t.

I was a college student with no programming, business, or design experience trying to learn Android so I could build a complex mobile app. I guess that’s what you get when you mix a big idea with the Silicon Valley hype machine.

I wish I could tell you things went well from here.

I bought a few books on Android development and spent countless hours in my room trying to duct-tape my app together. I didn’t care how the app worked, I just wanted a finished product.

Time went on and the app turned into a Frankenstein of copy and pasted code. The app didn’t have many features and it barely ran without crashing.

It wasn’t until I accidentally got into a Computer Science class that I realized that I should focus more on actually trying to learn software development.

My inability to program lead me to abandon my initial app idea. I'd come to the realization that I wasn’t going to make the next big thing, at least not yet.

Over time I corrected my behavior and took learning more seriously. I started to enjoy programming and eventually started a career as a software developer.

My big app idea consumed me for a long time. It put my focus on the end result rather than the process of getting there.

When you get too focused on the end result, you start taking shortcuts. Shortcuts might lead some short-term progress but in the long run, your lack of knowledge will always catch up to you.

It’s important to remember that learning anything big, like programming, requires many small steps. Each step will need to be treated with care.

Learning new things is like building a house. You start with the foundation and build up. If the foundation is faulty the whole thing will crumble down sooner or later.

Sometimes building a strong foundation requires you to slow down. There’s no shame in going slow. The people who understand the basics the first time will end up getting ahead of the people who have to go back and relearn them.

There’s an old Chinese proverb that goes:

"It is better to take many small steps in the right direction than to make a big leap forward only to stumble backward."

It's not how fast you can do something, it's how slowly you can do it correctly.

I was a perfect example. From the outside, it might’ve looked like I was a programming whiz kid. In reality, I couldn’t build an app to save my life.

Focus on the process and you will surprise yourself with how much progress you make each day.

Lesson #2: Stack Overflow is Awesome (But Dangerous)

As I was building my killer app, Stack Overflow became my best friend.

Anytime I got stuck I would try to craft together a perfect question to ask the Stack Overflow community. I averaged a few questions a day.

Not only would I post questions, but I would also treat the answers on Stack Overflow as Gospel. I would spend a crazy amount of time scouring the site to try to find an exact chunk of code that would fix my problem.

When I found a suitable answer, I would copy and paste it right into my codebase and try to make it work with my existing code. I spent little time trying to understand the code I was adding.

I made brute-force trial and error a new art form.

This process went on for a while until eventually, I wised up and realized the flaws of my approach.

Stack Overflow is a blessing and a curse. It’s great at helping you solve problems – however, if you aren’t careful, you can quickly become dependent on the website.

Sometimes the website is too good at solving problems. It creates a false sense of confidence that can lead to more headaches down the road.

Stack Overflow shows you how to get something to work but it doesn't usually explicitly tell you why it works.

Understanding the how is important. Bugs need to be fixed and code needs to run.

However, understanding why something works is what's going to help you apply the knowledge again in the future.

It's like the quote...

"Give a man a fish, and you feed him for a day. Teach a man to fish, and you feed him for a lifetime."

Copy and pasting code from Stack Overflow is like giving someone a fish. Understanding why a snippet of code works is like teaching them to fish.

There's nothing wrong with copying and pasting code. We all do it. It's only a problem when it becomes a crutch and stunts our growth as a developer.

The thing I had to learn the hard way was that it's impossible to learn anything if the answers are constantly given to you. There are no short-cuts in the learning process.

When you're stuck, attempt to solve your coding problem at least a few times before going to Google.

When you find yourself copying and pasting code, spend a little time trying to understand the code snippet before moving on.

Lesson #3: Learn How to Find Experienced Help

The first thing I did after I decided I wanted to learn programming was buy two Android development books.

At the start, I followed the exercises in the books closely and worked through the example projects. However, I quickly got frustrated with the progress I was making following the book and decided to go off and figure out how to program on my own.

As you’ve read above, that slowly resulted in disaster.

I spent countless hours isolated in my room trying to figure out simple programming problems. I was getting stuck on every new line of code and it didn't feel like I was making much progress.

I was helplessly stuck and my life was a cocktail of doubt, frustration, and an overwhelming feeling of being lost.

To make matters worse, I had the bright idea to start using a massive C library called FFMPEG. My app needed to edit videos, so I thought it was a good idea to utilize the library’s robust functionality.

It wasn’t my smartest move, considering at the time, I could barely get my Android app working.

I wasted a lot of time trying to read the C code and figuring out how I could use it in my app. I struggled to even get the library imported into my Android project. The Android code and C code didn't want to play nice.

After many hours of getting nowhere, I eventually became frustrated and abandoned the library.

Around the same time as the FFMPEG debacle, I signed up for an Object Oriented Programming class. I'm honestly not sure how I got in. I later found out that I was the only non-Computer Science major in the class. I think there was a bug in the enrollment software.

The first assignment was to build a Blackjack program. I’d been teaching myself programming for 5-6 months at this point, and I felt somewhat confident with my skills.

I finished the assignment and felt good about my work.

It didn't take long for that feeling to fade.

My whole program was written in one huge method. Just about everyone else in the class was able to pick up on the fact that the program needed to be separated into classes.

Not good.

Luckily, the classwork and guidance from the teacher allowed me to take a step back from my Android app and reflect on my programming abilities. I started to value learning and reigned back my desires to make a completed app.

I've now come to realize that if I would've spoken to just one experienced developer in those early days, they would’ve seen what I was doing. I could have set my priorities straight, and talked some sense into me. They would’ve helped me correct my path when I was going down useless dead ends (like trying to work with FFMPEG).

Instead, I isolated myself from the world partially because I felt like there wasn’t anyone who could help me.

Isolation is a double-edged sword. On one side, it helps you focus on the task at hand. On the flip side, it removes you from the world, starving you of crucial feedback.

There were a lot of ways I could’ve found help. I could’ve tried to find a professor/student at the university with Android experience or looked to the local community for help. I also could’ve tried finding an online Android community.

Experienced developers are like a compass. They won’t get you to your destination but they will make sure you are pointed in the right direction. Their help can often be the difference between success and failure.

Make sure you seek out guidance wherever you can find it. It will save you time and frustration down the road.

Lesson #4: Craft Your Environment

This might be the only thing I felt like I did right when I was teaching myself programming.

Throughout my life, I’ve been really bad at studying for tests or doing my homework at home. There are just too many distractions at any given moment. I would often try to find refuge in libraries or coffee shops.

Luckily I applied this rule when I was teaching myself programming.

I ended up becoming a regular at a few local coffee shops. I preferred coffee shops over other study locations because they provided some variety and it’s easy to hide (easy access to caffeine doesn’t hurt either).

If I was studying at home, I made sure my door was shut and my roommates knew not to disturb me for a certain period of time.

Regardless of where I was, I would make sure my music was loud enough so I couldn’t hear what was going on around me.

I can’t say I was perfect at finding a distraction-free work environment but I was able to succeed a majority of the time.

Having the right work environment is often an overlooked part of learning.

Focus is a foundational component of memory and skill acquisition. When you try to learn something new, the strength of the learning is directly linked to the intensity of your focus. When your focus is weak, new information will be less sticky which will result in slower learning and more time studying.

Your work environment should be distraction-free and should allow for long uninterrupted stretches of focus. Even with COVID-19 making it necessary to work remotely, there are still actions you can take to design your learning environment.

Here are a few things you can do:

  • Find a location where people won’t interrupt you
  • Put your phone in airplane mode
  • Use some sort of timed website blocker for social media and news sites
  • Wear headphones and listen to non-distracting music (preferably a long playlist so you don’t have to constantly switch songs)
  • Avoid TV or other highly stimulating surroundings
  • Have a notebook nearby to write down any tasks or ideas that pop into your head
  • Make it known to the people around you that you don't want to be disturbed

Only you can decide where and how to craft your environment. But make sure you do, because it’s worth it.

Lesson #5: Get Out Into the World and Meet People

Landing my first programming job was sort of a random occurrence.

I just moved to Omaha, Nebraska and I had around a year of self-taught development under my belt.

I knew very few people in Omaha, so I searched to try and find other people interested in Android development. I found a Meetup focused on mobile development which covered both iOS and Android development and I decided to go.

Going to that first meeting was nerve-racking. I spent around 10 minutes in my car at the venue deciding if I should go in or drive off.

I was intimidated. I wasn’t confident of my programming skills and I knew everyone at the Meetup had much more experience than I did.

I finally said, screw it and went inside.

I’m glad I did.

I started to attend regularly and during one Meetup, not too long after I moved to Omaha, I met a recruiter who was looking for an Android contractor. We talked for a while and I got an interview for the job later that week.

Before the interview, I felt confident. During the interview, I was a deer in the headlights.

The interviewer was talking about the project I’d be working on and it all went right over my head. I tried to stay engaged but they could tell it was out of my range.

After the interview, they asked me to hang-out for an hour so I could talk to someone else. Knowing I blew it, I walked around downtown trying to clear my head.

I ended up interviewing with someone else at the company, and shortly after, they offered me an internship.

I was so shocked that after I signed all the paperwork and got my work laptop running, I went over to the CEO and asked if it was a paid internship or not.

The internship turned into a full-time job and I started my career as a software developer.

When you are self-taught, people are not going to come and seek you out. You will need to find opportunities for yourself.

Graduates of four-year universities and code schools have the advantage of leveraging their school's network when finding a job. Self-taught developers don’t have this luxury.

Self-taught developers will need to go out into the world and build their networks themselves.

Cold calling employers and sending out resumes can work. However, I've found people like hiring people who are close to them in their social network.

Websites like are great for finding monthly programming-specific groups. Even in a pandemic, there are still many virtual Meetups that are very informative and beneficial.

There are also other Slack channels or Discord communities that you can leverage to make meaningful relationships. You can also try reaching out to various people in your area and ask to have a quick 15-minute virtual coffee with them.

Do what you can to build up the nerve to reach out and talk with people. Be friendly and talk to them about your experiences. Make sure people know of your long-term goal of finding a job.

Put yourself in situations where something positive might happen. You can’t win a raffle if you never buy a ticket.

Consider any opportunity that comes your way, because even if it looks like a dead-end, it has the potential to lead to something bigger.

My internship was a huge pay-cut to the other offers I had at the time. However, I knew if I worked hard it would be an opportunity for me to break into the tech industry.

The key is to think of job opportunities in the long-term. Internships or part-time jobs might not give you your desired salary upfront but they might open up doors in the future.

I Hope You Learn From My Mistakes and Make Exciting New Mistakes of Your Own

As you can see, I made a lot of mistakes in my journey of becoming a self-taught developer.

Teaching yourself to code is never a straight road. All our stories are unique.

The key is to keep going and to avoid getting discouraged when things aren't going your way.

I encourage other self-taught developers to share their stories. Not only will they provide valuable insights, but they will also help shine a light on the unique paths we’ve taken.

Hopefully, my story and the lessons I learned will help you moving forward.

Thanks for reading. If you want to hear about other insights I've learned along the way, follow my account Zero to Programmer on Twitter. My goal is to help you learn programming more efficiently.